nativescript 9.1.0-alpha.1 → 9.1.0-alpha.3

package/lib/commands/prepare.js

@@ -22,6 +22,11 @@ class PrepareCommand extends command_base_1.ValidatePlatformCommandBase {
                 hasSensitiveValue: false,
             },
             hmr: { type: "boolean" /* OptionType.Boolean */, default: false, hasSensitiveValue: false },
+            skipNative: {
+                type: "boolean" /* OptionType.Boolean */,
+                default: false,
+                hasSensitiveValue: false,
+            },
             whatever: {
                 type: "boolean" /* OptionType.Boolean */,
                 default: false,

package/lib/controllers/run-controller.js

@@ -15,7 +15,7 @@ const util = require("util");
 const _ = require("lodash");
 const yok_1 = require("../common/yok");
 class RunController extends events_1.EventEmitter {
-    constructor($analyticsService, $buildController, $debugController, $deviceInstallAppService, $devicesService, $errors, $injector, $hmrStatusService, $hooksService, $liveSyncServiceResolver, $liveSyncProcessDataService, $logger, $mobileHelper, $platformsDataService, $pluginsService, $prepareController, $prepareDataService, $prepareNativePlatformService, $projectChangesService, $projectDataService) {
+    constructor($analyticsService, $buildController, $debugController, $deviceInstallAppService, $devicesService, $errors, $injector, $hmrStatusService, $hooksService, $liveSyncServiceResolver, $liveSyncProcessDataService, $logger, $mobileHelper, $platformsDataService, $pluginsService, $prepareController, $prepareDataService, $prepareNativePlatformService, $projectChangesService, $projectDataService, $staticConfig) {
         super();
         this.$analyticsService = $analyticsService;
         this.$buildController = $buildController;
@@ -37,7 +37,10 @@ class RunController extends events_1.EventEmitter {
         this.$prepareNativePlatformService = $prepareNativePlatformService;
         this.$projectChangesService = $projectChangesService;
         this.$projectDataService = $projectDataService;
+        this.$staticConfig = $staticConfig;
         this.prepareReadyEventHandler = null;
+        this._syncInProgress = false;
+        this._pendingSyncs = new Map();
     }
     async run(runData) {
         const { liveSyncInfo, deviceDescriptors } = runData;
@@ -60,13 +63,11 @@ class RunController extends events_1.EventEmitter {
                     const platformData = this.$platformsDataService.getPlatformData(data.platform, projectData);
                     const prepareData = this.$prepareDataService.getPrepareData(liveSyncInfo.projectDir, data.platform, { ...liveSyncInfo, watch: !liveSyncInfo.skipWatcher });
                     const changesInfo = await this.$projectChangesService.checkForChanges(platformData, projectData, prepareData);
-                    if (changesInfo.hasChanges) {
-                        await this.syncChangedDataOnDevices(data, projectData, liveSyncInfo);
+                    if (!changesInfo.hasChanges) {
+                        return;
                     }
                 }
-                else {
-                    await this.syncChangedDataOnDevices(data, projectData, liveSyncInfo);
-                }
+                this.scheduleSyncOnDevices(data, projectData, liveSyncInfo);
             };
             this.prepareReadyEventHandler = handler.bind(this);
             this.$prepareController.on(constants_2.PREPARE_READY_EVENT_NAME, this.prepareReadyEventHandler);
@@ -277,6 +278,14 @@ class RunController extends events_1.EventEmitter {
                 },
                 watch: !liveSyncInfo.skipWatcher,
             });
+            // For Android + Vite HMR, own the `adb reverse` ourselves —
+            // with our SDK-resolved adb, scoped to this exact serial, and
+            // only after the device is up — then hand the bundler the
+            // result via env vars. This MUST run before `prepare` (which
+            // spawns the Vite bundler that inherits `process.env`) so the
+            // bundler trusts the tunnel instead of racing us to spawn its
+            // own adb during config-load. See packages/vite hardening.
+            await this.setupAndroidViteHmrReverse(device, projectData, liveSyncInfo);
             const prepareResultData = await this.$prepareController.prepare(prepareData);
             const buildData = {
                 ...deviceDescriptor.buildData,
@@ -353,6 +362,91 @@ class RunController extends events_1.EventEmitter {
         };
         await this.addActionToChain(projectData.projectDir, () => this.$devicesService.execute(deviceAction, (device) => _.some(deviceDescriptors, (deviceDescriptor) => deviceDescriptor.identifier === device.deviceInfo.identifier)));
     }
+    /**
+     * Set up `adb reverse tcp:<port> tcp:<port>` for an Android device
+     * when the project bundles with Vite in HMR/watch mode, then export
+     * the result to the bundler subprocess via environment variables.
+     *
+     * The Vite dev-host helper prefers an ADB tunnel (device-side
+     * `127.0.0.1:<port>` → host) over the emulator's flaky slirp NAT
+     * (`10.0.2.2`). Historically the bundler tried to wire that tunnel
+     * itself at config-load time, racing this CLI's device discovery
+     * over the single global adb daemon and intermittently freezing the
+     * run at "Searching for devices…". The CLI is the right owner: it
+     * knows the exact target serial and when the device is ready, and it
+     * already drives a single, version-matched adb. We do the reverse
+     * here and signal the bundler with `NS_ADB_REVERSE_READY=1` so it
+     * never spawns adb on its own.
+     *
+     * Best-effort: any failure is logged at trace level and swallowed.
+     * The bundler then falls back to its own (now hardened) adb path, or
+     * ultimately to `10.0.2.2`, so a reverse hiccup never fails the run.
+     */
+    async setupAndroidViteHmrReverse(device, projectData, liveSyncInfo) {
+        try {
+            if (!this.$mobileHelper.isAndroidPlatform(device.deviceInfo.platform)) {
+                return;
+            }
+            if (projectData.bundler !== "vite") {
+                return;
+            }
+            // HMR over the tunnel only matters for a live watch session.
+            if (liveSyncInfo.skipWatcher || !liveSyncInfo.useHotModuleReload) {
+                return;
+            }
+            // Respect the user's explicit opt-out — they want the
+            // `10.0.2.2` / LAN path, so don't create a tunnel or claim one
+            // exists.
+            if (this.isTruthyEnvFlag(process.env.NS_HMR_NO_ADB_REVERSE)) {
+                return;
+            }
+            // `NS_HMR_PREFER_LAN_HOST` means the dev wants LAN routing
+            // (physical device over Wi-Fi); the dev-host resolver suppresses
+            // the adb-reverse path for it, so don't bother wiring one.
+            if (this.isTruthyEnvFlag(process.env.NS_HMR_PREFER_LAN_HOST)) {
+                return;
+            }
+            const serial = device.deviceInfo.identifier;
+            const port = this.getViteHmrPort();
+            // Safe after the `isAndroidPlatform` guard above — only Android
+            // devices carry the `adb` bridge.
+            const adb = device.adb;
+            // Don't `reverse` against a device whose adbd isn't accepting
+            // yet (emulators report a `device` transport before adbd is
+            // fully up). `wait-for-device` returns immediately once ready.
+            await adb.executeCommand(["wait-for-device"], {
+                deviceIdentifier: serial,
+            });
+            await adb.executeCommand(["reverse", `tcp:${port}`, `tcp:${port}`], {
+                deviceIdentifier: serial,
+            });
+            // Hand the exact adb the CLI used to the bundler so, in any
+            // fallback path, it drives the same version-matched client and
+            // can't trigger a server-version-mismatch daemon kill.
+            const adbPath = await this.$staticConfig.getAdbFilePath();
+            process.env.NS_ADB_PATH = adbPath;
+            process.env.NS_DEVICE_SERIAL = serial;
+            process.env.NS_ADB_REVERSE_READY = "1";
+            this.$logger.info(`Set up adb reverse tcp:${port} tcp:${port} for ${serial} (Vite HMR routes device-side 127.0.0.1:${port} through ADB).`);
+        }
+        catch (err) {
+            this.$logger.trace(`Setting up adb reverse for Vite HMR failed; leaving it to the bundler fallback. Error: ${err}`);
+        }
+    }
+    getViteHmrPort() {
+        // The Vite dev server defaults to 5173; the bundler reads the same
+        // default. If a project runs Vite on a different port, the dev sets
+        // `NS_HMR_PORT` so the CLI reverses the matching port.
+        const fromEnv = Number(process.env.NS_HMR_PORT);
+        return Number.isFinite(fromEnv) && fromEnv > 0 ? fromEnv : 5173;
+    }
+    isTruthyEnvFlag(value) {
+        if (typeof value !== "string") {
+            return false;
+        }
+        const v = value.trim().toLowerCase();
+        return !!v && v !== "0" && v !== "false" && v !== "off" && v !== "no";
+    }
     async syncChangedDataOnDevices(data, projectData, liveSyncInfo) {
         const successfullySyncedMessageFormat = `Successfully synced application %s on device %s.`;
         const rebuiltInformation = {};
@@ -476,18 +570,13 @@ class RunController extends events_1.EventEmitter {
                 }
             }
             catch (err) {
-                this.$logger.warn(`Unable to apply changes for device: ${device.deviceInfo.identifier}. Error is: ${err && err.message}.`);
+                this.$logger.warn(`Unable to apply changes for device: ${device.deviceInfo.identifier}. Error is: ${err && err.message}. Will retry on next change.`);
                 this.emitCore(constants_2.RunOnDeviceEvents.runOnDeviceError, {
                     projectDir: projectData.projectDir,
                     deviceIdentifier: device.deviceInfo.identifier,
                     applicationIdentifier: projectData.projectIdentifiers[device.deviceInfo.platform.toLowerCase()],
                     error: err,
                 });
-                await this.stop({
-                    projectDir: projectData.projectDir,
-                    deviceIdentifiers: [device.deviceInfo.identifier],
-                    stopOptions: { shouldAwaitAllActions: false },
-                });
             }
         };
         await this.addActionToChain(projectData.projectDir, () => this.$devicesService.execute(deviceAction, (device) => {
@@ -498,15 +587,65 @@ class RunController extends events_1.EventEmitter {
                 _.some(liveSyncProcessInfo.deviceDescriptors, (deviceDescriptor) => deviceDescriptor.identifier === device.deviceInfo.identifier));
         }));
     }
+    scheduleSyncOnDevices(data, projectData, liveSyncInfo) {
+        if (this._syncInProgress) {
+            const platform = data.platform;
+            const existing = this._pendingSyncs.get(platform);
+            if (existing) {
+                existing.data = this.mergeFilesChangeEvents(existing.data, data);
+            }
+            else {
+                this._pendingSyncs.set(platform, { data, projectData, liveSyncInfo });
+            }
+            return;
+        }
+        this.executeSyncOnDevices(data, projectData, liveSyncInfo);
+    }
+    async executeSyncOnDevices(data, projectData, liveSyncInfo) {
+        this._syncInProgress = true;
+        try {
+            await this.syncChangedDataOnDevices(data, projectData, liveSyncInfo);
+        }
+        catch (err) {
+            this.$logger.trace(`Error during sync on devices: ${err.message || err}`);
+        }
+        finally {
+            const nextEntry = this._pendingSyncs.entries().next();
+            if (!nextEntry.done) {
+                const [platform, pending] = nextEntry.value;
+                this._pendingSyncs.delete(platform);
+                this.executeSyncOnDevices(pending.data, pending.projectData, pending.liveSyncInfo);
+            }
+            else {
+                this._syncInProgress = false;
+            }
+        }
+    }
+    mergeFilesChangeEvents(a, b) {
+        return {
+            files: [...new Set([...a.files, ...b.files])],
+            staleFiles: [
+                ...new Set([...(a.staleFiles || []), ...(b.staleFiles || [])]),
+            ],
+            hasOnlyHotUpdateFiles: a.hasOnlyHotUpdateFiles && b.hasOnlyHotUpdateFiles,
+            hasNativeChanges: a.hasNativeChanges || b.hasNativeChanges,
+            hmrData: b.hmrData,
+            platform: b.platform,
+        };
+    }
     async addActionToChain(projectDir, action) {
         const liveSyncInfo = this.$liveSyncProcessDataService.getPersistedData(projectDir);
         if (liveSyncInfo) {
-            liveSyncInfo.actionsChain = liveSyncInfo.actionsChain.then(async () => {
+            liveSyncInfo.actionsChain = liveSyncInfo.actionsChain
+                .then(async () => {
                 if (!liveSyncInfo.isStopped) {
                     liveSyncInfo.currentSyncAction = action();
                     const res = await liveSyncInfo.currentSyncAction;
                     return res;
                 }
+            })
+                .catch((err) => {
+                this.$logger.warn(`Error in action chain: ${err.message || err}`);
             });
             const result = await liveSyncInfo.actionsChain;
             return result;

package/lib/data/prepare-data.js

@@ -33,6 +33,10 @@ class PrepareData extends controller_data_base_1.ControllerDataBase {
             this.watchNative = data.watchNative;
         }
         this.hostProjectPath = data.hostProjectPath;
+        if (data.skipNative) {
+            this.nativePrepare = { skipNativePrepare: true };
+            this.watchNative = false;
+        }
         this.uniqueBundle = !this.watch && data.uniqueBundle ? Date.now() : 0;
     }
 }

package/lib/declarations.d.ts

@@ -31,7 +31,7 @@ interface INodePackageManager {
 	install(
 		packageName: string,
 		pathToSave: string,
-		config: INodePackageManagerInstallOptions
+		config: INodePackageManagerInstallOptions,
 	): Promise<INpmInstallResultInfo>;
 
 	/**
@@ -44,7 +44,7 @@ interface INodePackageManager {
 	uninstall(
 		packageName: string,
 		config?: IDictionary<string | boolean>,
-		path?: string
+		path?: string,
 	): Promise<string>;
 
 	/**
@@ -84,7 +84,7 @@ interface INodePackageManager {
 	 */
 	search(
 		filter: string[],
-		config: IDictionary<string | boolean>
+		config: IDictionary<string | boolean>,
 	): Promise<string>;
 
 	/**
@@ -130,7 +130,7 @@ interface IPerformanceService {
 		methodInfo: string,
 		startTime: number,
 		endTime: number,
-		args: any[]
+		args: any[],
 	): void;
 
 	// Will return a reference time in milliseconds
@@ -141,39 +141,39 @@ interface IPackageInstallationManager {
 	install(
 		packageName: string,
 		packageDir: string,
-		options?: INpmInstallOptions
+		options?: INpmInstallOptions,
 	): Promise<any>;
 	uninstall(
 		packageName: string,
 		packageDir: string,
-		options?: IDictionary<string | boolean>
+		options?: IDictionary<string | boolean>,
 	): Promise<any>;
 	getLatestVersion(packageName: string): Promise<string>;
 	getNextVersion(packageName: string): Promise<string>;
 	getLatestCompatibleVersion(
 		packageName: string,
-		referenceVersion?: string
+		referenceVersion?: string,
 	): Promise<string>;
 	getMaxSatisfyingVersion(
 		packageName: string,
-		versionRange: string
+		versionRange: string,
 	): Promise<string>;
 	getLatestCompatibleVersionSafe(
 		packageName: string,
-		referenceVersion?: string
+		referenceVersion?: string,
 	): Promise<string>;
 	getInspectorFromCache(
 		inspectorNpmPackageName: string,
-		projectDir: string
+		projectDir: string,
 	): Promise<string>;
 	clearInspectorCache(): void;
 	getInstalledDependencyVersion(
 		packageName: string,
-		projectDir?: string
+		projectDir?: string,
 	): Promise<string>;
 	getMaxSatisfyingVersionSafe(
 		packageName: string,
-		versionIdentifier: string
+		versionIdentifier: string,
 	): Promise<string>;
 }
 
@@ -181,8 +181,7 @@ interface IPackageInstallationManager {
  * Describes options that can be passed to manipulate package installation.
  */
 interface INodePackageManagerInstallOptions
-	extends INpmInstallConfigurationOptions,
-		IDictionary<string | boolean> {
+	extends INpmInstallConfigurationOptions, IDictionary<string | boolean> {
 	/**
 	 * Destination of the installation.
 	 * @type {string}
@@ -266,7 +265,7 @@ interface INpmPeerDependencyInfo {
 				 * @type {string}
 				 */
 				requires: string;
-			}
+			},
 		];
 		/**
 		 * Dependencies of the dependency.
@@ -550,8 +549,7 @@ interface INpmInstallConfigurationOptionsBase {
 	ignoreScripts: boolean; //npm flag
 }
 
-interface INpmInstallConfigurationOptions
-	extends INpmInstallConfigurationOptionsBase {
+interface INpmInstallConfigurationOptions extends INpmInstallConfigurationOptionsBase {
 	disableNpmInstall: boolean;
 }
 
@@ -597,7 +595,8 @@ interface ITypingsOptions {
 }
 
 interface IOptions
-	extends IRelease,
+	extends
+		IRelease,
 		IDeviceIdentifier,
 		IJustLaunch,
 		IAvd,
@@ -622,7 +621,7 @@ interface IOptions
 	argv: IYargArgv;
 	validateOptions(
 		commandSpecificDashedOptions?: IDictionary<IDashedOption>,
-		projectData?: IProjectData
+		projectData?: IProjectData,
 	): void;
 	options: IDictionary<IDashedOption>;
 	shorthands: string[];
@@ -709,6 +708,7 @@ interface IOptions
 	dryRun: boolean;
 
 	platformOverride: string;
+	skipNative: boolean;
 	uniqueBundle: boolean;
 	// allow arbitrary options
 	[optionName: string]: any;
@@ -719,26 +719,22 @@ interface IEnvOptions {
 }
 
 interface IAndroidBuildOptionsSettings
-	extends IAndroidReleaseOptions,
-		IRelease,
-		Partial<IHasAndroidBundle> {}
+	extends IAndroidReleaseOptions, IRelease, Partial<IHasAndroidBundle> {}
 
 interface IHasAndroidBundle {
 	androidBundle: boolean;
 }
 
 interface IPlatformBuildData
-	extends IRelease,
-		IHasUseHotModuleReloadOption,
-		IBuildConfig,
-		IEnvOptions {}
+	extends IRelease, IHasUseHotModuleReloadOption, IBuildConfig, IEnvOptions {}
 
 interface IDeviceEmulator extends IHasEmulatorOption, IDeviceIdentifier {}
 
 interface IRunPlatformOptions extends IJustLaunch, IDeviceEmulator {}
 
 interface IDeployPlatformOptions
-	extends IAndroidReleaseOptions,
+	extends
+		IAndroidReleaseOptions,
 		IRelease,
 		IClean,
 		IDeviceEmulator,
@@ -834,7 +830,7 @@ interface IAndroidToolsInfo {
 	 */
 	validateJavacVersion(
 		installedJavaVersion: string,
-		options?: IAndroidToolsInfoOptions
+		options?: IAndroidToolsInfoOptions,
 	): boolean;
 
 	/**
@@ -913,14 +909,14 @@ interface IAppDebugSocketProxyFactory extends NodeJS.EventEmitter {
 		device: Mobile.IiOSDevice,
 		appId: string,
 		projectName: string,
-		projectDir: string
+		projectDir: string,
 	): Promise<any>;
 
 	ensureWebSocketProxy(
 		device: Mobile.IiOSDevice,
 		appId: string,
 		projectName: string,
-		projectDir: string
+		projectDir: string,
 	): Promise<any>;
 
 	removeAllProxies(): void;
@@ -939,12 +935,12 @@ interface IiOSSocketRequestExecutor {
 	executeAttachRequest(
 		device: Mobile.IiOSDevice,
 		timeout: number,
-		projectId: string
+		projectId: string,
 	): Promise<void>;
 	executeRefreshRequest(
 		device: Mobile.IiOSDevice,
 		timeout: number,
-		appId: string
+		appId: string,
 	): Promise<boolean>;
 }
 
@@ -995,7 +991,7 @@ interface IProjectNameService {
 	 */
 	ensureValidName(
 		projectName: string,
-		validateOptions?: { force: boolean }
+		validateOptions?: { force: boolean },
 	): Promise<string>;
 }
 
@@ -1089,7 +1085,7 @@ interface IBundleValidatorHelper {
 	 */
 	getBundlerDependencyVersion(
 		projectData: IProjectData,
-		bundlerName?: string
+		bundlerName?: string,
 	): string;
 }
 
@@ -1171,7 +1167,7 @@ interface IAssetsGenerationService {
 	 * @returns {Promise<void>}
 	 */
 	generateSplashScreens(
-		splashesGenerationData: IResourceGenerationData
+		splashesGenerationData: IResourceGenerationData,
 	): Promise<void>;
 }
 
@@ -1207,7 +1203,7 @@ interface IPlatformValidationService {
 		provision: true | string,
 		teamId: true | string,
 		projectData: IProjectData,
-		platform?: string
+		platform?: string,
 	): Promise<boolean>;
 
 	validatePlatformInstalled(platform: string, projectData: IProjectData): void;
@@ -1220,7 +1216,7 @@ interface IPlatformValidationService {
 	 */
 	isPlatformSupportedForOS(
 		platform: string,
-		projectData: IProjectData
+		projectData: IProjectData,
 	): boolean;
 }
 
@@ -1228,27 +1224,27 @@ interface IPlatformCommandHelper {
 	addPlatforms(
 		platforms: string[],
 		projectData: IProjectData,
-		frameworkPath?: string
+		frameworkPath?: string,
 	): Promise<void>;
 	cleanPlatforms(
 		platforms: string[],
 		projectData: IProjectData,
-		frameworkPath: string
+		frameworkPath: string,
 	): Promise<void>;
 	removePlatforms(
 		platforms: string[],
-		projectData: IProjectData
+		projectData: IProjectData,
 	): Promise<void>;
 	updatePlatforms(
 		platforms: string[],
-		projectData: IProjectData
+		projectData: IProjectData,
 	): Promise<void>;
 	getInstalledPlatforms(projectData: IProjectData): string[];
 	getAvailablePlatforms(projectData: IProjectData): string[];
 	getPreparedPlatforms(projectData: IProjectData): string[];
 	getCurrentPlatformVersion(
 		platform: string,
-		projectData: IProjectData
+		projectData: IProjectData,
 	): string;
 }
 

package/lib/options.js

@@ -225,6 +225,7 @@ class Options {
                 default: true,
             },
             dryRun: { type: "boolean" /* OptionType.Boolean */, hasSensitiveValue: false },
+            skipNative: { type: "boolean" /* OptionType.Boolean */, hasSensitiveValue: false },
             uniqueBundle: { type: "boolean" /* OptionType.Boolean */, hasSensitiveValue: false },
         };
     }

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

@@ -36,6 +36,9 @@ class BundlerCompilerService extends events_1.EventEmitter {
         this.bundlerProcesses = {};
         this.expectedHashes = {};
     }
+    getViteDistOutputPath(projectDir) {
+        return path.join(projectDir, process.env.NS_VITE_DIST_DIR || constants_1.VITE_DIST_FOLDER_NAME);
+    }
     async compileWithWatch(platformData, projectData, prepareData) {
         return new Promise(async (resolve, reject) => {
             if (this.bundlerProcesses[platformData.platformNameLowerCase]) {
@@ -67,7 +70,7 @@ class BundlerCompilerService extends events_1.EventEmitter {
                             console.log("Received Vite IPC message:", message);
                         }
                         // Copy Vite output files directly to platform destination
-                        const distOutput = path.join(projectData.projectDir, constants_1.VITE_DIST_FOLDER_NAME);
+                        const distOutput = this.getViteDistOutputPath(projectData.projectDir);
                         const destDir = path.join(platformData.appDestinationDirectoryPath, this.$options.hostProjectModuleName);
                         if (debugLog) {
                             console.log(`Copying from ${distOutput} to ${destDir}.`);
@@ -232,7 +235,7 @@ class BundlerCompilerService extends events_1.EventEmitter {
                         // launch with `Check failed: has_pending_exception()`.
                         if (isVite) {
                             try {
-                                const distOutput = path.join(projectData.projectDir, constants_1.VITE_DIST_FOLDER_NAME);
+                                const distOutput = this.getViteDistOutputPath(projectData.projectDir);
                                 const destDir = path.join(platformData.appDestinationDirectoryPath, this.$options.hostProjectModuleName);
                                 this.copyViteBundleToNative(distOutput, destDir);
                             }

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));
         }
     }
     /**
@@ -623,6 +626,27 @@ class IOSProjectService extends projectServiceBaseLib.PlatformProjectServiceBase
         await this.prepareFrameworks(pluginPlatformsFolderPath, pluginData, projectData);
         await this.prepareStaticLibs(pluginPlatformsFolderPath, pluginData, projectData);
     }
+    shouldRepreparePlugin(pluginData, projectData) {
+        const pluginPlatformsFolderPath = pluginData.pluginPlatformsFolderPath(IOSProjectService.IOS_PLATFORM_NAME);
+        for (const fileName of this.getAllLibsForPluginWithFileExtension(pluginData, ".a")) {
+            const staticLibPath = path.join(pluginPlatformsFolderPath, fileName);
+            const libraryName = path.basename(staticLibPath, ".a");
+            const headersSubpath = path.join(path.dirname(staticLibPath), "include", libraryName);
+            if (!this.$fs.exists(headersSubpath)) {
+                continue;
+            }
+            const headerFiles = this.$fs
+                .readDirectory(headersSubpath)
+                .filter((f) => path.extname(f) === ".h" &&
+                this.$fs.getFsStats(path.join(headersSubpath, f)).isFile());
+            if (headerFiles.length > 0 &&
+                !this.$fs.exists(path.join(headersSubpath, "module.modulemap"))) {
+                this.$logger.trace(`Plugin ${pluginData.name}: modulemap missing at ${headersSubpath}, will re-prepare`);
+                return true;
+            }
+        }
+        return false;
+    }
     async removePluginNativeCode(pluginData, projectData) {
         const pluginPlatformsFolderPath = pluginData.pluginPlatformsFolderPath(IOSProjectService.IOS_PLATFORM_NAME);
         this.removeNativeSourceCode(pluginPlatformsFolderPath, pluginData, projectData);

package/lib/services/plugins-service.js

@@ -107,6 +107,7 @@ class PluginsService {
         }
     }
     async preparePluginNativeCode({ pluginData, platform, projectData, }) {
+        var _a, _b, _c;
         const platformData = this.$platformsDataService.getPlatformData(platform, projectData);
         const pluginPlatformsFolderPath = pluginData.pluginPlatformsFolderPath(platform);
         if (this.$fs.exists(pluginPlatformsFolderPath)) {
@@ -114,8 +115,10 @@ class PluginsService {
             const allPluginsNativeHashes = this.getAllPluginsNativeHashes(pathToPluginsBuildFile);
             const oldPluginNativeHashes = allPluginsNativeHashes[pluginData.name];
             const currentPluginNativeHashes = await this.getPluginNativeHashes(pluginPlatformsFolderPath);
-            if (!oldPluginNativeHashes ||
-                this.$filesHashService.hasChangesInShasums(oldPluginNativeHashes, currentPluginNativeHashes)) {
+            const needsReprepare = !oldPluginNativeHashes ||
+                this.$filesHashService.hasChangesInShasums(oldPluginNativeHashes, currentPluginNativeHashes) ||
+                ((_c = (_b = (_a = platformData.platformProjectService).shouldRepreparePlugin) === null || _b === void 0 ? void 0 : _b.call(_a, pluginData, projectData)) !== null && _c !== void 0 ? _c : false);
+            if (needsReprepare) {
                 await platformData.platformProjectService.preparePluginNativeCode(pluginData, projectData);
                 const updatedPluginNativeHashes = await this.getPluginNativeHashes(pluginPlatformsFolderPath);
                 this.setPluginNativeHashes({
@@ -366,7 +369,12 @@ This framework comes from ${dependencyName} plugin, which is installed multiple
     getNodeModuleData(module, projectDir) {
         // module can be  modulePath or moduleName
         if (!this.$fs.exists(module) || path.basename(module) !== "package.json") {
-            module = this.getPackageJsonFilePathForModule(module, projectDir);
+            const resolvedPath = this.getPackageJsonFilePathForModule(module, projectDir);
+            if (!resolvedPath) {
+                this.$logger.warn(`Could not find module ${color_1.color.yellow(module)}. It may have been removed or is not installed. Skipping.`);
+                return null;
+            }
+            module = resolvedPath;
         }
         const data = this.$fs.readJson(module);
         return {
@@ -384,7 +392,7 @@ This framework comes from ${dependencyName} plugin, which is installed multiple
     async getAllInstalledModules(projectData) {
         await this.ensure(projectData);
         const nodeModules = this.getDependencies(projectData.projectDir);
-        return _.map(nodeModules, (nodeModuleName) => this.getNodeModuleData(nodeModuleName, projectData.projectDir));
+        return _.map(nodeModules, (nodeModuleName) => this.getNodeModuleData(nodeModuleName, projectData.projectDir)).filter(Boolean);
     }
     async executeNpmCommand(npmCommandName, npmCommandArguments, projectData) {
         if (npmCommandName === PluginsService.INSTALL_COMMAND_NAME) {

package/package.json

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