nativescript 9.1.0-alpha.0 → 9.1.0-alpha.10

package/lib/controllers/prepare-controller.js

@@ -15,6 +15,7 @@ const decorators_1 = require("../common/decorators");
 const helpers_1 = require("../common/helpers");
 const yok_1 = require("../common/yok");
 const constants_1 = require("../constants");
+const resolve_package_path_1 = require("@rigor789/resolve-package-path");
 class PrepareController extends events_1.EventEmitter {
     constructor($platformController, $hooksService, $fs, $logger, $options, $mobileHelper, $nodeModulesDependenciesBuilder, $platformsDataService, $pluginsService, $prepareNativePlatformService, $projectChangesService, $projectDataService, $bundlerCompilerService, $watchIgnoreListService, $analyticsService, $markingModeService, $projectConfigService, $projectService) {
         super();
@@ -100,7 +101,6 @@ class PrepareController extends events_1.EventEmitter {
                 platform: prepareData.platform.toLowerCase(),
             };
         }
-        this.syncMacOSBundleArtifacts(projectData, platformData);
         await this.writeRuntimePackageJson(projectData, platformData, prepareData);
         await this.$projectChangesService.savePrepareInfo(platformData, projectData, prepareData);
         this.$logger.info(`Project successfully prepared (${prepareData.platform.toLowerCase()})`);
@@ -230,28 +230,69 @@ class PrepareController extends events_1.EventEmitter {
      * TODO: move this logic to the webpack side of things - WIP and deprecate here with a webpack version check...
      */
     async writeRuntimePackageJson(projectData, platformData, prepareData = null) {
+        var _a, _b, _c, _d, _e;
         const configInfo = this.$projectConfigService.detectProjectConfigs(projectData.projectDir);
         if (configInfo.usingNSConfig) {
             return;
         }
         this.$logger.info("Updating runtime package.json with configuration values...");
-        const nsConfig = this.$projectConfigService.readConfig(projectData.projectDir);
+        // Tolerate a missing/unreadable config — prior to the destructure this
+        // was a plain object spread, where `undefined` is a legal no-op.
+        const { hooks, ignoredNativeDependencies, webpackPackageName, webpackConfigPath, appResourcesPath, buildPath, appPath, ...nsConfig } = (_a = this.$projectConfigService.readConfig(projectData.projectDir)) !== null && _a !== void 0 ? _a : {};
+        const platform = platformData.platformNameLowerCase;
+        let installedRuntimePackageJSON;
+        let runtimePackageName;
+        if (platform === "ios" /* PlatformTypes.ios */) {
+            runtimePackageName =
+                ((_c = (_b = projectData.nsConfig) === null || _b === void 0 ? void 0 : _b.ios) === null || _c === void 0 ? void 0 : _c.runtimePackageName) ||
+                    constants_1.SCOPED_IOS_RUNTIME_NAME;
+        }
+        else if (platform === "android" /* PlatformTypes.android */) {
+            runtimePackageName =
+                ((_e = (_d = projectData.nsConfig) === null || _d === void 0 ? void 0 : _d.android) === null || _e === void 0 ? void 0 : _e.runtimePackageName) ||
+                    constants_1.SCOPED_ANDROID_RUNTIME_NAME;
+        }
+        // try reading from installed runtime first before reading from the npm registry...
+        const installedRuntimePackageJSONPath = (0, resolve_package_path_1.resolvePackageJSONPath)(runtimePackageName, {
+            paths: [projectData.projectDir],
+        });
+        if (installedRuntimePackageJSONPath) {
+            installedRuntimePackageJSON = this.$fs.readJson(installedRuntimePackageJSONPath);
+        }
         const packageData = {
             ..._.pick(projectData.packageJsonData, ["name"]),
             ...nsConfig,
             main: "bundle",
+            ...(installedRuntimePackageJSON ? {} : {}),
         };
-        if (platformData.platformNameLowerCase === "ios" &&
-            packageData.ios &&
-            packageData.ios.discardUncaughtJsExceptions) {
-            packageData.discardUncaughtJsExceptions =
-                packageData.ios.discardUncaughtJsExceptions;
+        if (platform === "ios" /* PlatformTypes.ios */) {
+            if (installedRuntimePackageJSON) {
+                packageData.ios = packageData.ios || {};
+                packageData.ios.runtime = {
+                    version: installedRuntimePackageJSON.version,
+                };
+            }
+            if (packageData.ios && packageData.ios.discardUncaughtJsExceptions) {
+                packageData.discardUncaughtJsExceptions =
+                    packageData.ios.discardUncaughtJsExceptions;
+            }
+            delete packageData.android;
         }
-        if (platformData.platformNameLowerCase === "android" &&
-            packageData.android &&
-            packageData.android.discardUncaughtJsExceptions) {
-            packageData.discardUncaughtJsExceptions =
-                packageData.android.discardUncaughtJsExceptions;
+        if (platform === "android" /* PlatformTypes.android */) {
+            if (installedRuntimePackageJSON) {
+                packageData.android = packageData.android || {};
+                packageData.android.runtime = {
+                    version: installedRuntimePackageJSON.version,
+                    version_info: installedRuntimePackageJSON.version_info,
+                    gradle: installedRuntimePackageJSON.gradle,
+                };
+            }
+            if (packageData.android &&
+                packageData.android.discardUncaughtJsExceptions) {
+                packageData.discardUncaughtJsExceptions =
+                    packageData.android.discardUncaughtJsExceptions;
+            }
+            delete packageData.ios;
         }
         let packagePath;
         if (this.$mobileHelper.isApplePlatform(platformData.platformNameLowerCase)) {
@@ -278,33 +319,6 @@ class PrepareController extends events_1.EventEmitter {
         }
         this.$fs.writeJson(packagePath, packageData);
     }
-    syncMacOSBundleArtifacts(projectData, platformData) {
-        if (platformData.platformNameLowerCase !== "macos") {
-            return;
-        }
-        if (process.env.NS_MACOS_IOS_BUNDLE_FALLBACK !== "1") {
-            return;
-        }
-        const macosAppPath = path.join(platformData.projectRoot, projectData.projectName, "app");
-        const hasMacBundle = this.$fs.exists(path.join(macosAppPath, "bundle.js")) ||
-            this.$fs.exists(path.join(macosAppPath, "bundle.mjs"));
-        if (hasMacBundle) {
-            return;
-        }
-        const iosAppPath = path.join(projectData.platformsDir, "ios", projectData.projectName, "app");
-        if (!this.$fs.exists(iosAppPath)) {
-            return;
-        }
-        this.$logger.trace(`Copying bundle artifacts from ${iosAppPath} to ${macosAppPath} for macOS prepare.`);
-        this.$fs.ensureDirectoryExists(macosAppPath);
-        const emittedFiles = this.$fs.enumerateFilesInDirectorySync(iosAppPath);
-        emittedFiles.forEach((sourcePath) => {
-            const relativePath = path.relative(iosAppPath, sourcePath);
-            const destinationPath = path.join(macosAppPath, relativePath);
-            this.$fs.ensureDirectoryExists(path.dirname(destinationPath));
-            this.$fs.copyFile(sourcePath, destinationPath);
-        });
-    }
     emitPrepareEvent(filesChangeEventData) {
         if (this.isInitialPrepareReady) {
             this.emit(constants_1.PREPARE_READY_EVENT_NAME, filesChangeEventData);

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, "pre-build");
             const prepareResultData = await this.$prepareController.prepare(prepareData);
             const buildData = {
                 ...deviceDescriptor.buildData,
@@ -327,6 +336,11 @@ class RunController extends events_1.EventEmitter {
                     watch: !skipWatcher,
                     liveSyncDeviceData: deviceDescriptor,
                 });
+                // Re-establish the adb reverse on the CURRENT transport right
+                // before launch — the transport can change during build/install
+                // and drop the mapping set in `pre-build`, which would leave the
+                // app unable to reach the Vite dev server at 127.0.0.1.
+                await this.setupAndroidViteHmrReverse(device, projectData, liveSyncInfo, "pre-launch");
                 await this.refreshApplication(projectData, liveSyncResultInfo, null, deviceDescriptor);
                 this.$logger.info(`Successfully synced application ${liveSyncResultInfo.deviceAppData.appIdentifier} on device ${liveSyncResultInfo.deviceAppData.device.deviceInfo.identifier}.`);
                 this.emitCore(constants_2.RunOnDeviceEvents.runOnDeviceStarted, {
@@ -353,6 +367,134 @@ 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, phase) {
+        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();
+            if (phase === "pre-build") {
+                // Decide the origin baked into bundle.mjs. Hand the bundler our
+                // exact adb (so any self-managed fallback can't version-mismatch
+                // the daemon) and, if the tunnel comes up, tell it to emit
+                // `127.0.0.1` and skip adb entirely.
+                process.env.NS_ADB_PATH = await this.$staticConfig.getAdbFilePath();
+                process.env.NS_DEVICE_SERIAL = serial;
+                const ok = await this.ensureAndroidReverse(device, serial, port);
+                if (ok) {
+                    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).`);
+                }
+                else {
+                    this.$logger.warn(`Could not confirm 'adb reverse tcp:${port}' on ${serial} (device adbd slow/unresponsive). Vite HMR will fall back to 10.0.2.2. If this persists, cold-boot/wipe the emulator, or set NS_HMR_NO_ADB_REVERSE=1.`);
+                }
+                return;
+            }
+            // phase === "pre-launch": re-establish the mapping right before the
+            // app boots. `adb reverse` mappings are bound to the device's adb
+            // transport, and that transport can change during the (long) build
+            // + install (fresh emulators reconnect as they settle), silently
+            // dropping the early mapping. We only bother when we actually told
+            // the bundle to use `127.0.0.1` (READY set during pre-build).
+            if (!this.isTruthyEnvFlag(process.env.NS_ADB_REVERSE_READY)) {
+                return;
+            }
+            const ok = await this.ensureAndroidReverse(device, serial, port);
+            if (!ok) {
+                this.$logger.warn(`adb reverse tcp:${port} was not active before launch on ${serial}; the app may fail to reach the Vite dev server at 127.0.0.1:${port}.`);
+            }
+        }
+        catch (err) {
+            this.$logger.trace(`Setting up adb reverse for Vite HMR (${phase}) failed; leaving it to the bundler fallback. Error: ${err}`);
+        }
+    }
+    /**
+     * Apply `adb reverse tcp:<port> tcp:<port>` to the device and confirm
+     * via `adb reverse --list` that it actually landed, retrying a few
+     * times. Every device-side call is bounded with a Node `spawn` timeout
+     * + `SIGKILL` so a wedged/slow adbd (observed blocking 90s+ on some
+     * fresh-boot / API-36 arm64 emulators) can never hang the run — the
+     * hung adb child is reaped, not orphaned. Returns whether the mapping
+     * is confirmed present.
+     */
+    async ensureAndroidReverse(device, serial, port) {
+        var _a, _b, _c;
+        const adb = device.adb;
+        const ADB_WAIT_MS = 15000;
+        const ADB_REVERSE_MS = 20000;
+        const bounded = (timeout) => ({
+            deviceIdentifier: serial,
+            treatErrorsAsWarnings: true,
+            childProcessOptions: { timeout, killSignal: "SIGKILL" },
+        });
+        // `wait-for-device` only blocks until the transport is up; bounded so a
+        // never-ready device can't stall us.
+        await adb.executeCommand(["wait-for-device"], bounded(ADB_WAIT_MS));
+        for (let attempt = 1; attempt <= 3; attempt++) {
+            await adb.executeCommand(["reverse", `tcp:${port}`, `tcp:${port}`], bounded(ADB_REVERSE_MS));
+            // Verify it landed (a SIGKILL'd-on-timeout reverse resolves rather
+            // than throws, so success of the call isn't proof).
+            const list = (_c = (_b = (_a = (await adb.executeCommand(["reverse", "--list"], bounded(ADB_WAIT_MS)))) === null || _a === void 0 ? void 0 : _a.toString) === null || _b === void 0 ? void 0 : _b.call(_a)) !== null && _c !== void 0 ? _c : "";
+            if (list.includes(`tcp:${port}`)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    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 +618,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 +635,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;
     }
 }