nativescript 9.1.0-alpha.15 → 9.1.0-alpha.17

package/lib/controllers/prepare-controller.d.ts

@@ -0,0 +1,45 @@
+import { EventEmitter } from "events";
+import { IAnalyticsService, IFileSystem, IHooksService } from "../common/declarations";
+import { IOptions, IWatchIgnoreListService } from "../declarations";
+import { INodeModulesDependenciesBuilder, IPlatformController, IPlatformData, IPlatformsDataService } from "../definitions/platform";
+import { IPluginsService } from "../definitions/plugins";
+import { IProjectConfigService, IProjectData, IProjectDataService, IProjectService } from "../definitions/project";
+export declare class PrepareController extends EventEmitter {
+    private $platformController;
+    $hooksService: IHooksService;
+    private $fs;
+    private $logger;
+    private $options;
+    private $mobileHelper;
+    private $nodeModulesDependenciesBuilder;
+    private $platformsDataService;
+    private $pluginsService;
+    private $prepareNativePlatformService;
+    private $projectChangesService;
+    private $projectDataService;
+    private $bundlerCompilerService;
+    private $watchIgnoreListService;
+    private $analyticsService;
+    private $markingModeService;
+    private $projectConfigService;
+    private $projectService;
+    private watchersData;
+    private isInitialPrepareReady;
+    private persistedData;
+    private webpackCompilerHandler;
+    private pausedFileWatch;
+    constructor($platformController: IPlatformController, $hooksService: IHooksService, $fs: IFileSystem, $logger: ILogger, $options: IOptions, $mobileHelper: Mobile.IMobileHelper, $nodeModulesDependenciesBuilder: INodeModulesDependenciesBuilder, $platformsDataService: IPlatformsDataService, $pluginsService: IPluginsService, $prepareNativePlatformService: IPrepareNativePlatformService, $projectChangesService: IProjectChangesService, $projectDataService: IProjectDataService, $bundlerCompilerService: IBundlerCompilerService, $watchIgnoreListService: IWatchIgnoreListService, $analyticsService: IAnalyticsService, $markingModeService: IMarkingModeService, $projectConfigService: IProjectConfigService, $projectService: IProjectService);
+    prepare(prepareData: IPrepareData): Promise<IPrepareResultData>;
+    stopWatchers(projectDir: string, platform: string): Promise<void>;
+    private prepareCore;
+    private startWatchersWithPrepare;
+    private startJSWatcherWithPrepare;
+    private startNativeWatcherWithPrepare;
+    private startNativeWatcher;
+    getWatcherPatterns(platformData: IPlatformData, projectData: IProjectData): Promise<string[]>;
+    writeRuntimePackageJson(projectData: IProjectData, platformData: IPlatformData, prepareData?: IPrepareData): Promise<void>;
+    private emitPrepareEvent;
+    private trackRuntimeVersion;
+    private isFileWatcherPaused;
+    toggleFileWatcher(): Promise<boolean>;
+}

package/lib/controllers/prepare-controller.js

@@ -77,10 +77,6 @@ class PrepareController extends events_1.EventEmitter {
         await this.$platformController.addPlatformIfNeeded(prepareData, projectData);
         await this.trackRuntimeVersion(prepareData.platform, projectData);
         this.$logger.info("Preparing project...");
-        // we need to mark the ~/package.json (used by core modules)
-        // as external for us to be able to write the config to it
-        // in writeRuntimePackageJson() below, because otherwise
-        // webpack will inline it into the bundle/vendor chunks
         prepareData.env = prepareData.env || {};
         prepareData.env.externals = prepareData.env.externals || [];
         prepareData.env.externals.push("~/package.json");
@@ -121,8 +117,8 @@ class PrepareController extends events_1.EventEmitter {
                 },
             };
         }
-        await this.startJSWatcherWithPrepare(platformData, projectData, prepareData); // -> start watcher + initial compilation
-        const hasNativeChanges = await this.startNativeWatcherWithPrepare(platformData, projectData, prepareData); // -> start watcher + initial prepare
+        await this.startJSWatcherWithPrepare(platformData, projectData, prepareData);
+        const hasNativeChanges = await this.startNativeWatcherWithPrepare(platformData, projectData, prepareData);
         const result = {
             platform: platformData.platformNameLowerCase,
             hasNativeChanges,
@@ -131,7 +127,6 @@ class PrepareController extends events_1.EventEmitter {
         if (hasPersistedDataWithNativeChanges) {
             result.hasNativeChanges = true;
         }
-        // TODO: Do not persist this in `this` context. Also it should be per platform.
         this.isInitialPrepareReady = true;
         if (this.persistedData && this.persistedData.length) {
             this.emitPrepareEvent({
@@ -184,7 +179,7 @@ class PrepareController extends events_1.EventEmitter {
                 pollInterval: 100,
                 stabilityThreshold: 500,
             },
-            ignored: ["**/.*", ".*"], // hidden files
+            ignored: ["**/.*", ".*"],
         };
         const watcher = (0, chokidar_1.watch)(patterns, watcherOptions).on("all", async (event, filePath) => {
             if (this.isFileWatcherPaused())
@@ -226,9 +221,6 @@ class PrepareController extends events_1.EventEmitter {
             .concat(pluginsPackageJsonFiles);
         return patterns;
     }
-    /**
-     * 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);
@@ -236,23 +228,20 @@ class PrepareController extends events_1.EventEmitter {
             return;
         }
         this.$logger.info("Updating runtime package.json with configuration values...");
-        // 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 */) {
+        if (platform === constants_1.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 */) {
+        else if (platform === constants_1.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],
         });
@@ -265,7 +254,7 @@ class PrepareController extends events_1.EventEmitter {
             main: "bundle",
             ...(installedRuntimePackageJSON ? {} : {}),
         };
-        if (platform === "ios" /* PlatformTypes.ios */) {
+        if (platform === constants_1.PlatformTypes.ios) {
             if (installedRuntimePackageJSON) {
                 packageData.ios = packageData.ios || {};
                 packageData.ios.runtime = {
@@ -278,7 +267,7 @@ class PrepareController extends events_1.EventEmitter {
             }
             delete packageData.android;
         }
-        if (platform === "android" /* PlatformTypes.android */) {
+        if (platform === constants_1.PlatformTypes.android) {
             if (installedRuntimePackageJSON) {
                 packageData.android = packageData.android || {};
                 packageData.android.runtime = {
@@ -302,11 +291,7 @@ class PrepareController extends events_1.EventEmitter {
             packagePath = path.join(platformData.projectRoot, this.$options.hostProjectModuleName, "src", this.$options.hostProjectPath ? "nativescript" : "main", "assets", "app", "package.json");
         }
         try {
-            // this will read the package.json that is already emitted by
-            // the GenerateNativeScriptEntryPointsPlugin webpack plugin
             const emittedPackageData = this.$fs.readJson(packagePath);
-            // since ns7 we only care about the main key from the emitted
-            // package.json, the rest is coming from the new config.
             if (emittedPackageData === null || emittedPackageData === void 0 ? void 0 : emittedPackageData.main) {
                 packageData.main = emittedPackageData.main;
             }
@@ -334,7 +319,7 @@ class PrepareController extends events_1.EventEmitter {
             return;
         }
         await this.$analyticsService.trackEventActionInGoogleAnalytics({
-            action: "Using Runtime Version" /* TrackActionNames.UsingRuntimeVersion */,
+            action: constants_1.TrackActionNames.UsingRuntimeVersion,
             additionalData: `${platform.toLowerCase()}${constants_1.AnalyticsEventLabelDelimiter}${version}`,
         });
     }
@@ -379,4 +364,3 @@ __decorate([
     (0, decorators_1.cache)()
 ], PrepareController.prototype, "trackRuntimeVersion", null);
 yok_1.injector.register("prepareController", PrepareController);
-//# sourceMappingURL=prepare-controller.js.map

package/lib/controllers/run-controller.d.ts

@@ -0,0 +1,57 @@
+import { EventEmitter } from "events";
+import { IProjectDataService, IProjectData } from "../definitions/project";
+import { IBuildController } from "../definitions/build";
+import { IPlatformsDataService } from "../definitions/platform";
+import { IDebugController } from "../definitions/debug";
+import { IPluginsService } from "../definitions/plugins";
+import { IAnalyticsService, IErrors, IHooksService } from "../common/declarations";
+import { IInjector } from "../common/definitions/yok";
+export declare class RunController extends EventEmitter implements IRunController {
+    protected $analyticsService: IAnalyticsService;
+    private $buildController;
+    private $debugController;
+    private $deviceInstallAppService;
+    protected $devicesService: Mobile.IDevicesService;
+    protected $errors: IErrors;
+    protected $injector: IInjector;
+    private $hmrStatusService;
+    $hooksService: IHooksService;
+    private $liveSyncServiceResolver;
+    private $liveSyncProcessDataService;
+    protected $logger: ILogger;
+    protected $mobileHelper: Mobile.IMobileHelper;
+    private $platformsDataService;
+    private $pluginsService;
+    private $prepareController;
+    private $prepareDataService;
+    private $prepareNativePlatformService;
+    private $projectChangesService;
+    protected $projectDataService: IProjectDataService;
+    private $staticConfig;
+    private prepareReadyEventHandler;
+    private _syncInProgress;
+    private _pendingSyncs;
+    constructor($analyticsService: IAnalyticsService, $buildController: IBuildController, $debugController: IDebugController, $deviceInstallAppService: IDeviceInstallAppService, $devicesService: Mobile.IDevicesService, $errors: IErrors, $injector: IInjector, $hmrStatusService: IHmrStatusService, $hooksService: IHooksService, $liveSyncServiceResolver: ILiveSyncServiceResolver, $liveSyncProcessDataService: ILiveSyncProcessDataService, $logger: ILogger, $mobileHelper: Mobile.IMobileHelper, $platformsDataService: IPlatformsDataService, $pluginsService: IPluginsService, $prepareController: IPrepareController, $prepareDataService: IPrepareDataService, $prepareNativePlatformService: IPrepareNativePlatformService, $projectChangesService: IProjectChangesService, $projectDataService: IProjectDataService, $staticConfig: Config.IStaticConfig);
+    run(runData: IRunData): Promise<void>;
+    stop(data: IStopRunData): Promise<void>;
+    getDeviceDescriptors(data: {
+        projectDir: string;
+    }): ILiveSyncDeviceDescriptor[];
+    protected refreshApplication(projectData: IProjectData, liveSyncResultInfo: ILiveSyncResultInfo, filesChangeEventData: IFilesChangeEventData, deviceDescriptor: ILiveSyncDeviceDescriptor, fullSyncAction?: () => Promise<void>): Promise<IRestartApplicationInfo>;
+    protected refreshApplicationWithDebug(projectData: IProjectData, liveSyncResultInfo: ILiveSyncResultInfo, filesChangeEventData: IFilesChangeEventData, deviceDescriptor: ILiveSyncDeviceDescriptor): Promise<IRestartApplicationInfo>;
+    protected refreshApplicationWithoutDebug(projectData: IProjectData, liveSyncResultInfo: ILiveSyncResultInfo, filesChangeEventData: IFilesChangeEventData, deviceDescriptor: ILiveSyncDeviceDescriptor, settings?: IRefreshApplicationSettings, fullSyncAction?: () => Promise<void>): Promise<IRestartApplicationInfo>;
+    private getDeviceDescriptorsForInitialSync;
+    private initializeSetup;
+    private attachDeviceLostHandler;
+    private syncInitialDataOnDevices;
+    private setupAndroidViteHmrReverse;
+    private ensureAndroidReverse;
+    private getViteHmrPort;
+    private isTruthyEnvFlag;
+    private syncChangedDataOnDevices;
+    private scheduleSyncOnDevices;
+    private executeSyncOnDevices;
+    private mergeFilesChangeEvents;
+    private addActionToChain;
+    private emitCore;
+}

package/lib/controllers/run-controller.js

@@ -79,14 +79,11 @@ class RunController extends events_1.EventEmitter {
         const { projectDir, deviceIdentifiers, stopOptions } = data;
         const liveSyncProcessInfo = this.$liveSyncProcessDataService.getPersistedData(projectDir);
         if (liveSyncProcessInfo && !liveSyncProcessInfo.isStopped) {
-            // In case we are coming from error during livesync, the current action is the one that erred (but we are still executing it),
-            // so we cannot await it as this will cause infinite loop.
             const shouldAwaitPendingOperation = !stopOptions || stopOptions.shouldAwaitAllActions;
             const deviceIdentifiersToRemove = deviceIdentifiers && deviceIdentifiers.length
                 ? deviceIdentifiers
                 : _.map(liveSyncProcessInfo.deviceDescriptors, (d) => d.identifier);
             const removedDeviceIdentifiers = _.remove(liveSyncProcessInfo.deviceDescriptors, (descriptor) => _.includes(deviceIdentifiersToRemove, descriptor.identifier)).map((descriptor) => descriptor.identifier);
-            // Handle the case when no more devices left for any of the persisted platforms
             for (let i = 0; i < liveSyncProcessInfo.platforms.length; i++) {
                 const platform = liveSyncProcessInfo.platforms[i];
                 const devices = this.$devicesService.getDevicesForPlatform(platform);
@@ -94,7 +91,6 @@ class RunController extends events_1.EventEmitter {
                     await this.$prepareController.stopWatchers(projectDir, platform);
                 }
             }
-            // In case deviceIdentifiers are not passed, we should stop the whole LiveSync.
             if (!deviceIdentifiers ||
                 !deviceIdentifiers.length ||
                 !liveSyncProcessInfo.deviceDescriptors ||
@@ -125,7 +121,6 @@ class RunController extends events_1.EventEmitter {
                 shouldAwaitPendingOperation) {
                 await liveSyncProcessInfo.currentSyncAction;
             }
-            // Emit RunOnDevice stopped when we've really stopped.
             _.each(removedDeviceIdentifiers, (deviceIdentifier) => {
                 this.emitCore(constants_2.RunOnDeviceEvents.runOnDeviceStopped, {
                     projectDir,
@@ -163,8 +158,6 @@ class RunController extends events_1.EventEmitter {
             shouldSkipEmitLiveSyncNotification: true,
             shouldCheckDeveloperDiscImage: true,
         });
-        // we do not stop the application when debugBrk is false, so we need to attach, instead of launch
-        // if we try to send the launch request, the debugger port will not be printed and the command will timeout
         debugOptions.start = !debugOptions.debugBrk;
         debugOptions.forceDebuggerAttachedEvent = refreshInfo.didRestart;
         await this.$debugController.enableDebuggingCoreWithoutWaitingCurrentAction(projectData.projectDir, deviceDescriptor.identifier, debugOptions);
@@ -232,7 +225,6 @@ class RunController extends events_1.EventEmitter {
     getDeviceDescriptorsForInitialSync(projectDir, deviceDescriptors) {
         const currentRunData = this.$liveSyncProcessDataService.getPersistedData(projectDir);
         const isAlreadyLiveSyncing = currentRunData && !currentRunData.isStopped;
-        // Prevent cases where liveSync is called consecutive times with the same device, for example [ A, B, C ] and then [ A, B, D ] - we want to execute initialSync only for D.
         const deviceDescriptorsForInitialSync = isAlreadyLiveSyncing
             ? _.differenceBy(deviceDescriptors, currentRunData.deviceDescriptors, "identifier")
             : deviceDescriptors;
@@ -278,13 +270,6 @@ 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 = {
@@ -294,8 +279,6 @@ class RunController extends events_1.EventEmitter {
             const platformData = this.$platformsDataService.getPlatformData(device.deviceInfo.platform, projectData);
             try {
                 let packageFilePath = null;
-                // Case where we have three devices attached, a change that requires build is found,
-                // we'll rebuild the app only for the first device, but we should install new package on all three devices.
                 if (rebuiltInformation[platformData.platformNameLowerCase] &&
                     (this.$mobileHelper.isAndroidPlatform(platformData.platformNameLowerCase) ||
                         rebuiltInformation[platformData.platformNameLowerCase]
@@ -319,7 +302,7 @@ class RunController extends events_1.EventEmitter {
                     }
                     else {
                         await this.$analyticsService.trackEventActionInGoogleAnalytics({
-                            action: "LiveSync" /* TrackActionNames.LiveSync */,
+                            action: constants_2.TrackActionNames.LiveSync,
                             device,
                             projectDir: projectData.projectDir,
                         });
@@ -336,10 +319,6 @@ 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}.`);
@@ -367,26 +346,6 @@ 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)) {
@@ -395,29 +354,18 @@ class RunController extends events_1.EventEmitter {
             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);
@@ -430,12 +378,6 @@ class RunController extends events_1.EventEmitter {
                 }
                 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;
             }
@@ -448,15 +390,6 @@ class RunController extends events_1.EventEmitter {
             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;
@@ -467,13 +400,9 @@ class RunController extends events_1.EventEmitter {
             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;
@@ -482,9 +411,6 @@ class RunController extends events_1.EventEmitter {
         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;
     }
@@ -522,9 +448,6 @@ class RunController extends events_1.EventEmitter {
                 const watchInfo = {
                     liveSyncDeviceData: deviceDescriptor,
                     projectData,
-                    // todo: remove stale files once everything is stable
-                    // currently, watcher fires multiple times & may clean up unsynced files
-                    // filesToRemove: data.staleFiles ?? [],
                     filesToRemove: [],
                     filesToSync,
                     hmrData: data.hmrData,
@@ -570,7 +493,6 @@ class RunController extends events_1.EventEmitter {
                         const fullSyncAction = async () => {
                             watchInfo.filesToSync = allAppFiles;
                             const fullLiveSyncResultInfo = await platformLiveSyncService.liveSyncWatchAction(device, watchInfo);
-                            // IMPORTANT: keep the same instance as we rely on side effects
                             _.assign(liveSyncResultInfo, fullLiveSyncResultInfo);
                         };
                         await this.$hooksService.executeBeforeHooks("watchAction", {
@@ -585,7 +507,6 @@ class RunController extends events_1.EventEmitter {
                         await this.refreshApplication(projectData, liveSyncResultInfo, data, deviceDescriptor, fullSyncAction);
                         if (!liveSyncResultInfo.didRecover && isInHMRMode) {
                             const status = await this.$hmrStatusService.getHmrStatus(device.deviceInfo.identifier, data.hmrData.hash);
-                            // the timeout is assumed OK as the app could be blocked on a breakpoint
                             if (status === constants_1.HmrConstants.HMR_ERROR_STATUS) {
                                 await fullSyncAction();
                                 liveSyncResultInfo.isFullSync = true;
@@ -712,4 +633,3 @@ __decorate([
     (0, decorators_1.cache)()
 ], RunController.prototype, "attachDeviceLostHandler", null);
 yok_1.injector.register("runController", RunController);
-//# sourceMappingURL=run-controller.js.map

package/lib/controllers/update-controller-base.d.ts

@@ -0,0 +1,27 @@
+import { IProjectData } from "../definitions/project";
+import { IPlatformCommandHelper, IPackageInstallationManager, IPackageManager } from "../declarations";
+import { IPlatformsDataService } from "../definitions/platform";
+import { IDependency } from "../definitions/migrate";
+import { IFileSystem } from "../common/declarations";
+export declare class UpdateControllerBase {
+    protected $fs: IFileSystem;
+    protected $platformCommandHelper: IPlatformCommandHelper;
+    protected $platformsDataService: IPlatformsDataService;
+    protected $packageInstallationManager: IPackageInstallationManager;
+    protected $packageManager: IPackageManager;
+    protected $pacoteService: IPacoteService;
+    protected getPackageManifest: Function;
+    constructor($fs: IFileSystem, $platformCommandHelper: IPlatformCommandHelper, $platformsDataService: IPlatformsDataService, $packageInstallationManager: IPackageInstallationManager, $packageManager: IPackageManager, $pacoteService: IPacoteService);
+    protected restoreBackup(folders: string[], backupDir: string, projectDir: string): void;
+    protected backup(folders: string[], backupDir: string, projectDir: string): void;
+    protected hasDependency(dependency: IDependency, projectData: IProjectData): boolean;
+    protected hasRuntimeDependency({ platform, projectData, }: {
+        platform: string;
+        projectData: IProjectData;
+    }): boolean;
+    protected getMaxRuntimeVersion({ platform, projectData, }: {
+        platform: string;
+        projectData: IProjectData;
+    }): Promise<string>;
+    private _getPackageManifest;
+}

package/lib/controllers/update-controller-base.js

@@ -69,4 +69,3 @@ class UpdateControllerBase {
     }
 }
 exports.UpdateControllerBase = UpdateControllerBase;
-//# sourceMappingURL=update-controller-base.js.map

package/lib/controllers/update-controller.d.ts

@@ -0,0 +1,36 @@
+import { UpdateControllerBase } from "./update-controller-base";
+import { IProjectDataService, IProjectCleanupService, IProjectBackupService } from "../definitions/project";
+import { IPlatformsDataService } from "../definitions/platform";
+import { IPlatformCommandHelper, IPackageInstallationManager, IPackageManager } from "../declarations";
+import { IFileSystem, IErrors } from "../common/declarations";
+import { IDependency } from "../definitions/migrate";
+import { IPluginsService } from "../definitions/plugins";
+import { ITerminalSpinnerService } from "../definitions/terminal-spinner-service";
+export declare class UpdateController extends UpdateControllerBase implements IUpdateController {
+    protected $fs: IFileSystem;
+    protected $platformsDataService: IPlatformsDataService;
+    protected $platformCommandHelper: IPlatformCommandHelper;
+    protected $packageInstallationManager: IPackageInstallationManager;
+    protected $packageManager: IPackageManager;
+    protected $pluginsService: IPluginsService;
+    protected $pacoteService: IPacoteService;
+    private $logger;
+    private $errors;
+    private $projectDataService;
+    private $projectBackupService;
+    private $projectCleanupService;
+    private $terminalSpinnerService;
+    static readonly updatableDependencies: IDependency[];
+    static readonly backupFolderName: string;
+    static readonly pathsToBackup: string[];
+    private spinner;
+    constructor($fs: IFileSystem, $platformsDataService: IPlatformsDataService, $platformCommandHelper: IPlatformCommandHelper, $packageInstallationManager: IPackageInstallationManager, $packageManager: IPackageManager, $pluginsService: IPluginsService, $pacoteService: IPacoteService, $logger: ILogger, $errors: IErrors, $projectDataService: IProjectDataService, $projectBackupService: IProjectBackupService, $projectCleanupService: IProjectCleanupService, $terminalSpinnerService: ITerminalSpinnerService);
+    update(updateOptions: IUpdateOptions): Promise<void>;
+    shouldUpdate(updateOptions: IUpdateOptions): Promise<boolean>;
+    private updateDependencies;
+    private updateDependency;
+    private shouldUpdateDependency;
+    private getVersionFromTagOrVersion;
+    private backupProject;
+    private cleanUpProject;
+}

package/lib/controllers/update-controller.js

@@ -28,15 +28,12 @@ class UpdateController extends update_controller_base_1.UpdateControllerBase {
         this.spinner = this.$terminalSpinnerService.createSpinner();
         const projectData = this.$projectDataService.getProjectData(updateOptions.projectDir);
         updateOptions.version = updateOptions.version || constants_1.PackageVersion.LATEST;
-        // back up project files and folders
         this.spinner.info("Backing up project files before update");
         await this.backupProject();
         this.spinner.succeed("Project files have been backed up");
-        // clean up project files
         this.spinner.info("Cleaning up project files before update");
         await this.cleanUpProject();
         this.spinner.succeed("Project files have been cleaned up");
-        // update dependencies
         this.spinner.info("Updating project dependencies");
         await this.updateDependencies(projectData, updateOptions.version);
         this.spinner.succeed("Project dependencies have been updated");
@@ -82,10 +79,6 @@ class UpdateController extends update_controller_base_1.UpdateControllerBase {
         if (!shouldUpdate) {
             return;
         }
-        // check if the coerced version is the same as desired and prefix it with a ~
-        // for example:
-        // 8.0.0 -> ~8.0.0
-        // 8.0.8-next-XXX -> 8.0.8-next-XXX
         const updatedVersion = (() => {
             if (desiredVersion === version) {
                 return desiredVersion;
@@ -138,11 +131,9 @@ class UpdateController extends update_controller_base_1.UpdateControllerBase {
 }
 exports.UpdateController = UpdateController;
 UpdateController.updatableDependencies = [
-    // dependencies
     {
         packageName: "@nativescript/core",
     },
-    // devDependencies
     {
         packageName: "@nativescript/webpack",
         isDev: true,
@@ -151,7 +142,6 @@ UpdateController.updatableDependencies = [
         packageName: "@nativescript/types",
         isDev: true,
     },
-    // runtimes
     {
         packageName: "@nativescript/ios",
         isDev: true,
@@ -171,4 +161,3 @@ UpdateController.pathsToBackup = [
     constants.CONFIG_NS_FILE_NAME,
 ];
 yok_1.injector.register("updateController", UpdateController);
-//# sourceMappingURL=update-controller.js.map

package/lib/data/build-data.d.ts

@@ -0,0 +1,33 @@
+import { PrepareData } from "./prepare-data";
+import { IiOSBuildData, IBuildData } from "../definitions/build";
+export declare class BuildData extends PrepareData implements IBuildData {
+    device?: string;
+    _device?: Mobile.IDevice;
+    emulator?: boolean;
+    clean: boolean;
+    buildForDevice?: boolean;
+    buildOutputStdio?: string;
+    outputPath?: string;
+    copyTo?: string;
+    constructor(projectDir: string, platform: string, data: any);
+}
+export declare class IOSBuildData extends BuildData implements IiOSBuildData {
+    teamId: string;
+    provision: string;
+    mobileProvisionData: any;
+    buildForAppStore: boolean;
+    iCloudContainerEnvironment: string;
+    hostProjectPath: string;
+    constructor(projectDir: string, platform: string, data: any);
+}
+export declare class AndroidBuildData extends BuildData {
+    keyStoreAlias: string;
+    keyStorePath: string;
+    keyStoreAliasPassword: string;
+    keyStorePassword: string;
+    androidBundle: boolean;
+    gradlePath: string;
+    gradleArgs: string;
+    hostProjectPath: string;
+    constructor(projectDir: string, platform: string, data: any);
+}

package/lib/data/build-data.js

@@ -42,4 +42,3 @@ class AndroidBuildData extends BuildData {
     }
 }
 exports.AndroidBuildData = AndroidBuildData;
-//# sourceMappingURL=build-data.js.map

package/lib/data/controller-data-base.d.ts

@@ -0,0 +1,8 @@
+import { INativePrepare } from "../definitions/project";
+import { IControllerDataBase } from "../definitions/data";
+export declare class ControllerDataBase implements IControllerDataBase {
+    projectDir: string;
+    platform: string;
+    nativePrepare?: INativePrepare;
+    constructor(projectDir: string, platform: string, data: any);
+}

package/lib/data/controller-data-base.js

@@ -9,4 +9,3 @@ class ControllerDataBase {
     }
 }
 exports.ControllerDataBase = ControllerDataBase;
-//# sourceMappingURL=controller-data-base.js.map

package/lib/data/debug-data.d.ts

@@ -0,0 +1,2 @@
+export declare class DebugData {
+}

package/lib/data/debug-data.js

@@ -4,4 +4,3 @@ exports.DebugData = void 0;
 class DebugData {
 }
 exports.DebugData = DebugData;
-//# sourceMappingURL=debug-data.js.map

package/lib/data/platform-data.d.ts

@@ -0,0 +1,7 @@
+import { ControllerDataBase } from "./controller-data-base";
+export declare class AddPlatformData extends ControllerDataBase {
+    projectDir: string;
+    platform: string;
+    frameworkPath?: string;
+    constructor(projectDir: string, platform: string, data: any);
+}