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

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

@@ -16,11 +16,9 @@ const decorators_1 = require("../../common/decorators");
 const constants_1 = require("../../constants");
 const yok_1 = require("../../common/yok");
 const package_path_helper_1 = require("../../helpers/package-path-helper");
-/* for specific bundling debugging separate from logger */
 const debugLog = false;
 class BundlerCompilerService extends events_1.EventEmitter {
-    constructor($options, $errors, $childProcess, $fs, $hooksService, $hostInfo, $logger, $mobileHelper, $cleanupService, $packageManager, $packageInstallationManager, // private $sharedEventBus: ISharedEventBus
-    $projectConfigService) {
+    constructor($options, $errors, $childProcess, $fs, $hooksService, $hostInfo, $logger, $mobileHelper, $cleanupService, $packageManager, $packageInstallationManager, $projectConfigService) {
         super();
         this.$options = $options;
         this.$errors = $errors;
@@ -35,9 +33,6 @@ class BundlerCompilerService extends events_1.EventEmitter {
         this.$packageInstallationManager = $packageInstallationManager;
         this.$projectConfigService = $projectConfigService;
         this.bundlerProcesses = {};
-        // Vite-only: the long-lived `vite serve` dev server the device fetches
-        // modules and HMR updates from. Keyed by platform, managed by this CLI
-        // so users no longer need a separate `concurrently`/`wait-on` process.
         this.viteServeProcesses = {};
         this.expectedHashes = {};
     }
@@ -58,22 +53,9 @@ class BundlerCompilerService extends events_1.EventEmitter {
             }
             let isFirstBundlerWatchCompilation = true;
             prepareData.watch = true;
-            // Bring up the Vite HMR dev server the device fetches modules /
-            // HMR updates from. No-op unless bundler is vite + hmr + watch.
-            // Fired in parallel with the build watcher; both child processes
-            // inherit the adb-reverse env the run-controller set before
-            // prepare, so neither one spawns adb on its own. Not awaited HERE
-            // — but the first-build resolution below gates on it, because the
-            // app is (re)started as soon as `compileWithWatch` resolves and its
-            // very first HTTP module fetch dies on connection-refused if the
-            // server hasn't bound yet (a cold `vite serve` config load + vendor
-            // prebuild competes with this build watcher for CPU and can take
-            // 10-30s). Running both in parallel keeps the happy-path wall time
-            // at max(first build, server bind) instead of their sum.
             const viteDevServerStartup = this.startViteDevServer(platformData, projectData, prepareData);
             try {
                 const childProcess = await this.startBundleProcess(platformData, projectData, prepareData);
-                // Handle Vite differently from webpack
                 const isVite = this.getBundler() === "vite";
                 childProcess.stdout.on("data", function (data) {
                     process.stdout.write(data);
@@ -81,11 +63,8 @@ class BundlerCompilerService extends events_1.EventEmitter {
                 childProcess.stderr.on("data", function (data) {
                     process.stderr.write(data);
                 });
-                // For both Vite and webpack, we wait for the first build to complete
-                // Don't resolve immediately for Vite - wait for first IPC message
                 childProcess.on("message", (message) => {
                     this.$logger.trace(`Message from ${projectData.bundler}`, message);
-                    // Handle Vite messages
                     if (isVite &&
                         message &&
                         message.emittedFiles) {
@@ -93,16 +72,13 @@ class BundlerCompilerService extends events_1.EventEmitter {
                         if (debugLog) {
                             console.log("Received Vite IPC message:", message);
                         }
-                        // Copy Vite output files directly to platform destination
                         const { distOutput, destDir } = this.getViteBuildPaths(platformData, projectData);
                         if (debugLog) {
                             console.log(`Copying from ${distOutput} to ${destDir}.`);
                         }
-                        // Determine which files to copy based on build type and changes
                         if (message.buildType === "incremental" &&
                             message.emittedFiles &&
                             message.emittedFiles.length > 0) {
-                            // Incremental builds: only copy files that are likely affected by the changes
                             const filesToCopy = this.getIncrementalFilesToCopy(message.emittedFiles);
                             if (debugLog) {
                                 console.log("Incremental build - files to copy:", filesToCopy);
@@ -115,12 +91,6 @@ class BundlerCompilerService extends events_1.EventEmitter {
                             }
                             this.copyViteBundleToNative(distOutput, destDir);
                         }
-                        // Resolve the promise on first build completion — gated on
-                        // the HMR dev server being reachable (no-op resolve for
-                        // non-HMR runs). `startViteDevServer` never rejects and its
-                        // readiness probe is bounded, so this cannot hang the run;
-                        // on probe timeout we proceed and the device's own retry
-                        // handles any residual gap.
                         if (isFirstBundlerWatchCompilation) {
                             isFirstBundlerWatchCompilation = false;
                             if (debugLog) {
@@ -129,7 +99,6 @@ class BundlerCompilerService extends events_1.EventEmitter {
                             viteDevServerStartup.then(() => resolve(childProcess));
                             return;
                         }
-                        // Transform Vite message to match webpack format
                         const files = message.emittedFiles.map((file) => path.join(platformData.appDestinationDirectoryPath, this.$options.hostProjectModuleName, file));
                         const data = {
                             files,
@@ -147,23 +116,14 @@ class BundlerCompilerService extends events_1.EventEmitter {
                         this.emit(constants_1.BUNDLER_COMPILATION_COMPLETE, data);
                         return;
                     }
-                    // if we are on webpack5 - we handle HMR in a  slightly different way
                     if (typeof message === "object" &&
                         "version" in message &&
                         "type" in message) {
-                        // first compilation can be ignored because it will be synced regardless
-                        // handling it here would trigger 2 syncs
                         if (isFirstBundlerWatchCompilation) {
                             isFirstBundlerWatchCompilation = false;
                             resolve(childProcess);
                             return;
                         }
-                        // if ((message as IWebpackMessage).type === "hmr-status") {
-                        // 	// we pass message through our event-bus to be handled wherever needed
-                        // 	// in this case webpack-hmr-status-service listens for this event
-                        // 	this.$sharedEventBus.emit("webpack:hmr-status", message);
-                        // 	return;
-                        // }
                         return this.handleHMRMessage(message, platformData, projectData, prepareData);
                     }
                     if (message ===
@@ -179,7 +139,6 @@ class BundlerCompilerService extends events_1.EventEmitter {
                                 prepareData.hmr ? message.hash : "";
                             return;
                         }
-                        // Persist the previousHash value before calling `this.getUpdatedEmittedFiles` as it will modify the expectedHashes object with the current hash
                         const previousHash = this.expectedHashes[platformData.platformNameLowerCase];
                         let result;
                         if (prepareData.hmr) {
@@ -204,7 +163,6 @@ class BundlerCompilerService extends events_1.EventEmitter {
                             platform: platformData.platformNameLowerCase,
                         };
                         this.$logger.trace(`Generated data from ${projectData.bundler} message:`, data);
-                        // the hash of the compilation is the same as the previous one and there are only hot updates produced
                         if (data.hasOnlyHotUpdateFiles && previousHash === message.hash) {
                             return;
                         }
@@ -252,18 +210,6 @@ class BundlerCompilerService extends events_1.EventEmitter {
                     delete this.bundlerProcesses[platformData.platformNameLowerCase];
                     const exitCode = typeof arg === "number" ? arg : arg && arg.code;
                     if (exitCode === 0) {
-                        // Non-watch Vite builds spawn the child with stdio:"inherit"
-                        // (no IPC channel), so the emittedFiles message handler in
-                        // compileWithWatch never fires and the Vite output is never
-                        // copied to the platforms app folder. Mirror that copy step
-                        // here so release/CI prepare and build flows actually deploy
-                        // the freshly built bundle. Without this, the deploy folder
-                        // is left empty (or worse, runs stale dev/HMR artifacts from
-                        // a previous `ns debug` run) and the runtime crashes on
-                        // launch with `Check failed: has_pending_exception()`.
-                        // The copy must succeed for the build to succeed — a build
-                        // whose bundle never reached the native app is not a
-                        // successful build, so copy failures reject here.
                         try {
                             if (isVite) {
                                 const { distOutput, destDir } = this.getViteBuildPaths(platformData, projectData);
@@ -299,11 +245,9 @@ class BundlerCompilerService extends events_1.EventEmitter {
         }
     }
     async shouldUsePreserveSymlinksOption() {
-        // pnpm does not require symlink (https://github.com/nodejs/node-eps/issues/46#issuecomment-277373566)
-        // and it also does not work in some cases.
-        // Check https://github.com/NativeScript/nativescript-cli/issues/5259 for more information
         const currentPackageManager = await this.$packageManager.getPackageManagerName();
-        const res = currentPackageManager !== constants_1.PackageManagers.pnpm;
+        const res = currentPackageManager !== constants_1.PackageManagers.pnpm &&
+            currentPackageManager !== constants_1.PackageManagers.bun;
         return res;
     }
     async startBundleProcess(platformData, projectData, prepareData) {
@@ -320,7 +264,6 @@ class BundlerCompilerService extends events_1.EventEmitter {
         const envData = this.buildEnvData(platformData.platformNameLowerCase, projectData, prepareData);
         const isVite = this.getBundler() === "vite";
         const cliArgs = await this.buildEnvCommandLineParams(envData, platformData, projectData, prepareData);
-        // Note: With Vite, we need `--` to prevent vite cli from erroring on unknown options.
         const envParams = isVite
             ? [
                 `--mode=${prepareData.release ? "production" : "development"}`,
@@ -380,26 +323,6 @@ class BundlerCompilerService extends events_1.EventEmitter {
         const fromEnv = Number(process.env.NS_HMR_PORT);
         return Number.isFinite(fromEnv) && fromEnv > 0 ? fromEnv : 5173;
     }
-    /**
-     * Spawn and manage the Vite dev server (`vite serve`) for HMR.
-     *
-     * Why the CLI owns this. With Vite, HMR needs a long-lived dev server
-     * (HTTP + the `/ns-hmr` websocket on port 5173) that the device fetches
-     * modules and hot updates from — it is SEPARATE from the
-     * `vite build --watch` process that emits the `bundle.mjs` bootstrap
-     * baked into the app. Historically users wired this up themselves with
-     * `concurrently`/`wait-on`, which left two uncoordinated processes both
-     * touching adb during cold start (the source of the Android
-     * "Searching for devices…" freeze). By spawning it here as a child of
-     * the CLI, the dev server inherits the CLI's environment — crucially
-     * `NS_ADB_REVERSE_READY`/`NS_DEVICE_SERIAL`/`NS_ADB_PATH` set by the
-     * run-controller — so the CLI is the single adb owner and the dev
-     * server never spawns adb itself.
-     *
-     * No-op unless bundler is vite, HMR is on, watch mode, and not release.
-     * Best-effort: failures are logged, never thrown — a dev-server hiccup
-     * must not fail the run.
-     */
     async startViteDevServer(platformData, projectData, prepareData) {
         try {
             if (this.getBundler() !== "vite") {
@@ -413,10 +336,6 @@ class BundlerCompilerService extends events_1.EventEmitter {
                 return;
             }
             const port = this.getViteHmrPort();
-            // One dev server per port. Simultaneous multi-platform HMR in a
-            // single CLI invocation would collide on 5173 — that case still
-            // needs a distinct NS_HMR_PORT per platform, so skip + warn rather
-            // than fail to bind.
             const collidingPlatform = Object.keys(this.viteServeProcesses)[0];
             if (collidingPlatform) {
                 this.$logger.warn(`Vite dev server already running for '${collidingPlatform}' on port ${port}; skipping a second server for '${key}'. For simultaneous multi-platform HMR, set a distinct NS_HMR_PORT per platform.`);
@@ -428,9 +347,6 @@ class BundlerCompilerService extends events_1.EventEmitter {
             if (await this.shouldUsePreserveSymlinksOption()) {
                 additionalNodeArgs.push("--preserve-symlinks");
             }
-            // `vite serve` (not `build`): runs the dev server and watches on
-            // its own — no `--watch`. Env flags (`--env.android --env.hmr …`)
-            // go after `--` so vite's CLI doesn't choke on unknown options.
             const args = [
                 ...additionalNodeArgs,
                 this.getBundlerExecutablePath(projectData),
@@ -442,9 +358,6 @@ class BundlerCompilerService extends events_1.EventEmitter {
             ].filter(Boolean);
             const options = {
                 cwd: projectData.projectDir,
-                // Inherit so the dev server's URLs/logs stream to the user as
-                // before. No IPC needed here — the build watcher provides the
-                // bundle-complete IPC; the dev server is fetched over HTTP/ws.
                 stdio: "inherit",
                 env: {
                     ...process.env,
@@ -464,17 +377,11 @@ class BundlerCompilerService extends events_1.EventEmitter {
                     this.$logger.warn(`Vite dev server for ${key} exited with code ${code}.`);
                 }
             });
-            // Bounded readiness probe so we can surface a clear log once the
-            // device can actually reach modules.
             const ready = await this.waitForPort(port, 30000);
             if (ready) {
                 this.$logger.info(`Vite dev server ready on port ${port} (HMR for ${key}).`);
             }
             else {
-                // Warn (not trace): the first-build resolution in
-                // `compileWithWatch` gates on this method, so a probe timeout
-                // means the app will be deployed against a server that may not
-                // be up yet — the user should see why a boot might stall.
                 this.$logger.warn(`Vite dev server port ${port} not observed open within the readiness probe window; continuing (it may bind shortly).`);
             }
         }
@@ -482,10 +389,6 @@ class BundlerCompilerService extends events_1.EventEmitter {
             this.$logger.warn(`Failed to start the Vite dev server: ${err}. HMR may be unavailable.`);
         }
     }
-    /**
-     * Resolve true once `127.0.0.1:<port>` accepts a TCP connection, or
-     * false after `timeoutMs`. Used to detect the Vite dev server is up.
-     */
     waitForPort(port, timeoutMs) {
         const deadline = Date.now() + timeoutMs;
         return new Promise((resolve) => {
@@ -527,28 +430,16 @@ class BundlerCompilerService extends events_1.EventEmitter {
         });
         envData.verbose = envData.verbose || this.$logger.isVerbose();
         envData.production = envData.production || prepareData.release;
-        // add the config file name to the env data so the webpack process can read the
-        // correct config file when resolving the CLI lib and the config service
-        // we are explicitly setting it to false to force using the defaults
         envData.config =
             (_b = (_a = process.env.NATIVESCRIPT_CONFIG_NAME) !== null && _a !== void 0 ? _a : this.$options.config) !== null && _b !== void 0 ? _b : "false";
-        // explicitly set the env variable
         process.env.NATIVESCRIPT_CONFIG_NAME = envData.config;
-        // The snapshot generation is wrongly located in the Webpack plugin.
-        // It should be moved in the Native Prepare of the CLI or a Gradle task in the Runtime.
-        // As a workaround, we skip the mksnapshot, xxd and android-ndk calls based on skipNativePrepare.
-        // In this way the plugin will prepare only the snapshot JS entry without any native prepare and
-        // we will able to execute cloud builds with snapshot without having any local snapshot or Docker setup.
-        // TODO: Remove this flag when we remove the native part from the plugin.
         envData.skipSnapshotTools =
             prepareData.nativePrepare && prepareData.nativePrepare.skipNativePrepare;
-        // only set sourceMap if not explicitly set through a flag
         if (typeof ((_c = prepareData === null || prepareData === void 0 ? void 0 : prepareData.env) === null || _c === void 0 ? void 0 : _c.sourceMap) === "undefined") {
             if (!prepareData.release) {
                 envData.sourceMap = true;
             }
         }
-        // convert string to boolean
         if (envData.sourceMap === "true" || envData.sourceMap === "false") {
             envData.sourceMap = envData.sourceMap === "true";
         }
@@ -569,7 +460,6 @@ class BundlerCompilerService extends events_1.EventEmitter {
             }
             else if (this.$hostInfo.isWindows) {
                 if (projectData.bundler === "webpack") {
-                    //TODO: check this use case for webpack5 WEBPACK_PLUGIN_NAME
                     const minWebpackPluginWithWinSnapshotsVersion = "1.3.0";
                     const installedWebpackPluginVersion = await this.$packageInstallationManager.getInstalledDependencyVersion(constants_1.WEBPACK_PLUGIN_NAME, projectData.projectDir);
                     const hasWebpackPluginWithWinSnapshotsSupport = !!installedWebpackPluginVersion
@@ -603,15 +493,6 @@ class BundlerCompilerService extends events_1.EventEmitter {
     }
     getUpdatedEmittedFiles(allEmittedFiles, chunkFiles, nextHash, platform) {
         const currentHash = this.getCurrentHotUpdateHash(allEmittedFiles);
-        // This logic is needed as there are already cases when webpack doesn't emit any files physically.
-        // We've set noEmitOnErrors in webpack.config.js based on noEmitOnError from tsconfig.json,
-        // so webpack doesn't emit any files when noEmitOnErrors: true is set in webpack.config.js and
-        // there is a compilation error in the source code. On the other side, hmr generates new hot-update files
-        // on every change and the hash of the next hmr update is written inside hot-update.json file.
-        // Although webpack doesn't emit any files, hmr hash is still generated. The hash is generated per compilation no matter
-        // if files will be emitted or not. This way, the first successful compilation after fixing the compilation error generates
-        // a hash that is not the same as the one expected in the latest emitted hot-update.json file.
-        // As a result, the hmr chain is broken and the changes are not applied.
         const isHashValid = nextHash
             ? this.expectedHashes[platform] === currentHash
             : true;
@@ -630,7 +511,6 @@ class BundlerCompilerService extends events_1.EventEmitter {
         let hotHash;
         const hotUpdateScripts = emittedFiles.filter((x) => x.endsWith(".hot-update.js"));
         if (hotUpdateScripts && hotUpdateScripts.length) {
-            // the hash is the same for each hot update in the current compilation
             const hotUpdateName = hotUpdateScripts[0];
             const matcher = /^(.+)\.(.+)\.hot-update/gm;
             const matches = matcher.exec(hotUpdateName);
@@ -646,7 +526,6 @@ class BundlerCompilerService extends events_1.EventEmitter {
             bundlerProcess.kill("SIGINT");
             delete this.bundlerProcesses[platform];
         }
-        // Tear down the Vite dev server we manage alongside the build watcher.
         const viteServeProcess = this.viteServeProcesses[platform];
         if (viteServeProcess) {
             await this.$cleanupService.removeKillProcess(viteServeProcess.pid.toString());
@@ -655,7 +534,6 @@ class BundlerCompilerService extends events_1.EventEmitter {
         }
     }
     handleHMRMessage(message, platformData, projectData, prepareData) {
-        // handle new bundler hmr packets
         this.$logger.trace(`Received message from ${projectData.bundler} process:`, message);
         if (message.type !== "compilation") {
             return;
@@ -663,7 +541,6 @@ class BundlerCompilerService extends events_1.EventEmitter {
         this.$logger.trace(`${capitalizeFirstLetter(projectData.bundler)} build done!`);
         const files = message.data.emittedAssets.map((asset) => path.join(platformData.appDestinationDirectoryPath, this.$options.hostProjectModuleName, asset));
         const staleFiles = message.data.staleAssets.map((asset) => path.join(platformData.appDestinationDirectoryPath, this.$options.hostProjectModuleName, asset));
-        // extract last hash from emitted filenames
         const lastHash = (() => {
             const absoluteFileNameWithLastHash = files.find((fileName) => fileName.endsWith("hot-update.js"));
             if (!absoluteFileNameWithLastHash) {
@@ -676,7 +553,6 @@ class BundlerCompilerService extends events_1.EventEmitter {
             }
         })();
         if (!files.length) {
-            // ignore compilations if no new files are emitted
             return;
         }
         this.emit(constants_1.BUNDLER_COMPILATION_COMPLETE, {
@@ -740,25 +616,20 @@ class BundlerCompilerService extends events_1.EventEmitter {
         return this.$projectConfigService.getValue(`bundler`, "webpack");
     }
     copyViteBundleToNative(distOutput, destDir, specificFiles = null, failOnError = false) {
-        // Clean and copy Vite output to native platform folder
         if (debugLog) {
             console.log(`Copying Vite bundle from "${distOutput}" to "${destDir}".`);
         }
         try {
             if (specificFiles) {
-                // Selective mode: only copy specific files (incremental)
                 if (debugLog) {
                     console.log("Selective copy - copying specific files:", specificFiles);
                 }
-                // Ensure destination directory exists
                 this.$fs.createDirectory(destDir);
-                // Copy only the specified files
                 for (const file of specificFiles) {
                     const srcPath = path.join(distOutput, file);
                     const destPath = path.join(destDir, file);
                     if (!this.$fs.exists(srcPath))
                         continue;
-                    // create parent dirs
                     this.$fs.createDirectory(path.dirname(destPath));
                     this.$fs.copyFile(srcPath, destPath);
                     if (debugLog) {
@@ -767,22 +638,16 @@ class BundlerCompilerService extends events_1.EventEmitter {
                 }
             }
             else {
-                // Full build mode: clean and copy everything
                 if (debugLog) {
                     console.log("Full build: Copying all files.");
                 }
-                // Validate the source before touching the destination — cleaning
-                // destDir first would wipe a previously good bundle and leave an
-                // empty app folder behind a missing Vite output.
                 if (!this.$fs.exists(distOutput)) {
                     throw new Error(`Vite output directory does not exist: ${distOutput}`);
                 }
-                // Clean destination directory
                 if (this.$fs.exists(destDir)) {
                     this.$fs.deleteDirectory(destDir);
                 }
                 this.$fs.createDirectory(destDir);
-                // Copy all files from dist to platform destination
                 this.copyRecursiveSync(distOutput, destDir);
             }
         }
@@ -795,12 +660,9 @@ class BundlerCompilerService extends events_1.EventEmitter {
         }
     }
     getIncrementalFilesToCopy(emittedFiles) {
-        // For incremental builds, we need to determine which emitted files are likely affected
-        // by the source file changes
         const filesToCopy = [];
         const bundleFiles = emittedFiles.filter((file) => file.endsWith(".mjs") || file.endsWith(".js") || file.endsWith(".map"));
         filesToCopy.push(...bundleFiles);
-        // Only copy assets if there are explicit asset-related changes
         const assetFiles = emittedFiles.filter((file) => file.includes("assets/") ||
             file.includes("static/") ||
             file.includes("fonts/") ||
@@ -808,11 +670,9 @@ class BundlerCompilerService extends events_1.EventEmitter {
         if (assetFiles.length > 0) {
             filesToCopy.push(...assetFiles);
         }
-        // Remove duplicates and return
         return [...new Set(filesToCopy)];
     }
     copyRecursiveSync(src, dest) {
-        // Ensure destination exists
         this.$fs.createDirectory(dest);
         const entries = this.$fs.readDirectory(src);
         for (const name of entries) {
@@ -823,7 +683,6 @@ class BundlerCompilerService extends events_1.EventEmitter {
                 this.copyRecursiveSync(srcPath, destPath);
             }
             else if (lstats.isFile() || lstats.isSymbolicLink()) {
-                // create parent directory (copyFile will also ensure it, but keep explicit)
                 this.$fs.createDirectory(path.dirname(destPath));
                 this.$fs.copyFile(srcPath, destPath);
             }
@@ -838,4 +697,3 @@ function capitalizeFirstLetter(val) {
     return String(val).charAt(0).toUpperCase() + String(val).slice(1);
 }
 yok_1.injector.register("bundlerCompilerService", BundlerCompilerService);
-//# sourceMappingURL=bundler-compiler-service.js.map

package/lib/services/bundler/bundler.d.ts

@@ -0,0 +1,75 @@
+import { EventEmitter } from "events";
+import { BuildData } from "../../data/build-data";
+import { PrepareData } from "../../data/prepare-data";
+import { IPlatformProjectServiceBase, IProjectData, IValidatePlatformOutput } from "../../definitions/project";
+import { IOptions, IDependencyData } from "../../declarations";
+import { IPlatformData } from "../../definitions/platform";
+import { IPluginData } from "../../definitions/plugins";
+import { IRelease, ISpawnResult } from "../../common/declarations";
+import { IProjectChangesInfo, IPrepareInfo, IAddedNativePlatform } from "../../definitions/project-changes";
+import { INotConfiguredEnvOptions } from "../../common/definitions/commands";
+declare global {
+    interface IBundlerCompilerService extends EventEmitter {
+        compileWithWatch(platformData: IPlatformData, projectData: IProjectData, prepareData: IPrepareData): Promise<any>;
+        compileWithoutWatch(platformData: IPlatformData, projectData: IProjectData, prepareData: IPrepareData): Promise<void>;
+        stopBundlerCompiler(platform: string): Promise<void>;
+    }
+    interface IBundlerEnvOptions {
+        sourceMap?: boolean;
+        uglify?: boolean;
+        production?: boolean;
+    }
+    interface IProjectChangesService {
+        checkForChanges(platformData: IPlatformData, projectData: IProjectData, prepareData: IPrepareData): Promise<IProjectChangesInfo>;
+        getPrepareInfoFilePath(platformData: IPlatformData): string;
+        getPrepareInfo(platformData: IPlatformData): IPrepareInfo;
+        savePrepareInfo(platformData: IPlatformData, projectData: IProjectData, prepareData: IPrepareData): Promise<void>;
+        setNativePlatformStatus(platformData: IPlatformData, projectData: IProjectData, addedPlatform: IAddedNativePlatform): void;
+        currentChanges: IProjectChangesInfo;
+    }
+    interface IFilesChangeEventData {
+        platform: string;
+        files: string[];
+        staleFiles: string[];
+        hmrData: IPlatformHmrData;
+        hasOnlyHotUpdateFiles: boolean;
+        hasNativeChanges: boolean;
+    }
+    interface IBundlerEmitMessage {
+        emittedFiles: string[];
+        chunkFiles: string[];
+        hash: string;
+        changedFiles?: string[];
+        isHMR?: boolean;
+        filesToCopy?: string[];
+        buildType?: string;
+    }
+    interface IPlatformProjectService extends NodeJS.EventEmitter, IPlatformProjectServiceBase {
+        getPlatformData(projectData: IProjectData): IPlatformData;
+        validate(projectData: IProjectData, options: IOptions, notConfiguredEnvOptions?: INotConfiguredEnvOptions): Promise<IValidatePlatformOutput>;
+        createProject(frameworkDir: string, frameworkVersion: string, projectData: IProjectData): Promise<void>;
+        interpolateData(projectData: IProjectData): Promise<void>;
+        interpolateConfigurationFile(projectData: IProjectData): void;
+        afterCreateProject(projectRoot: string, projectData: IProjectData): void;
+        validateOptions(projectId?: string, provision?: true | string, teamId?: true | string): Promise<boolean>;
+        buildProject<T extends BuildData>(projectRoot: string, projectData: IProjectData, buildConfig: T): Promise<void>;
+        prepareProject<T extends PrepareData>(projectData: IProjectData, prepareData: T): Promise<void>;
+        prepareAppResources(projectData: IProjectData): void;
+        isPlatformPrepared(projectRoot: string, projectData: IProjectData): boolean;
+        preparePluginNativeCode(pluginData: IPluginData, options?: any): Promise<void>;
+        shouldRepreparePlugin?(pluginData: IPluginData, projectData: IProjectData): boolean;
+        removePluginNativeCode(pluginData: IPluginData, projectData: IProjectData): Promise<void>;
+        beforePrepareAllPlugins(projectData: IProjectData, dependencies?: IDependencyData[]): Promise<IDependencyData[]>;
+        handleNativeDependenciesChange(projectData: IProjectData, opts: IRelease): Promise<void>;
+        getAppResourcesDestinationDirectoryPath(projectData: IProjectData): string;
+        cleanDeviceTempFolder(deviceIdentifier: string, projectData: IProjectData): Promise<void>;
+        processConfigurationFilesFromAppResources(projectData: IProjectData, opts: {
+            release: boolean;
+        }): Promise<void>;
+        ensureConfigurationFileInAppResources(projectData: IProjectData): void;
+        stopServices?(projectRoot: string): Promise<ISpawnResult>;
+        cleanProject?(projectRoot: string): Promise<void>;
+        checkForChanges<T extends PrepareData>(changeset: IProjectChangesInfo, prepareData: T, projectData: IProjectData): Promise<void>;
+        getDeploymentTarget?(projectData: IProjectData): any;
+    }
+}

package/lib/services/bundler/bundler.js

@@ -1,3 +1,2 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=bundler.js.map

package/lib/services/cleanup-service.d.ts

@@ -0,0 +1,29 @@
+import { IOptions } from "../declarations";
+import { IChildProcess } from "../common/declarations";
+import { ICleanupService } from "../definitions/cleanup-service";
+import { ISpawnCommandInfo, IRequestInfo, IJSCommand } from "../detached-processes/cleanup-process-definitions";
+export declare class CleanupService implements ICleanupService {
+    private $staticConfig;
+    private $childProcess;
+    private static CLEANUP_PROCESS_START_TIMEOUT;
+    private pathToCleanupLogFile;
+    private cleanupProcess;
+    constructor($options: IOptions, $staticConfig: Config.IStaticConfig, $childProcess: IChildProcess);
+    shouldDispose: boolean;
+    addCleanupCommand(commandInfo: ISpawnCommandInfo): Promise<void>;
+    removeCleanupCommand(commandInfo: ISpawnCommandInfo): Promise<void>;
+    addRequest(requestInfo: IRequestInfo): Promise<void>;
+    removeRequest(requestInfo: IRequestInfo): Promise<void>;
+    addCleanupDeleteAction(filePath: string): Promise<void>;
+    removeCleanupDeleteAction(filePath: string): Promise<void>;
+    addCleanupJS(jsCommand: IJSCommand): Promise<void>;
+    removeCleanupJS(jsCommand: IJSCommand): Promise<void>;
+    addKillProcess(pid: string): Promise<void>;
+    removeKillProcess(pid: string): Promise<void>;
+    setCleanupLogFile(filePath: string): void;
+    dispose(): void;
+    setShouldDispose(shouldDispose: boolean): void;
+    private getCleanupProcess;
+    private getCleanupProcessArgs;
+    private getKillProcesSpawnInfo;
+}

package/lib/services/cleanup-service.js

@@ -10,6 +10,7 @@ exports.CleanupService = void 0;
 const path = require("path");
 const decorators_1 = require("../common/decorators");
 const yok_1 = require("../common/yok");
+const detached_process_enums_1 = require("../detached-processes/detached-process-enums");
 class CleanupService {
     constructor($options, $staticConfig, $childProcess) {
         this.$staticConfig = $staticConfig;
@@ -20,56 +21,56 @@ class CleanupService {
     async addCleanupCommand(commandInfo) {
         const cleanupProcess = await this.getCleanupProcess();
         cleanupProcess.send({
-            messageType: "AddCleanCommand" /* CleanupProcessMessage.AddCleanCommand */,
+            messageType: detached_process_enums_1.CleanupProcessMessage.AddCleanCommand,
             commandInfo,
         });
     }
     async removeCleanupCommand(commandInfo) {
         const cleanupProcess = await this.getCleanupProcess();
         cleanupProcess.send({
-            messageType: "RemoveCleanCommand" /* CleanupProcessMessage.RemoveCleanCommand */,
+            messageType: detached_process_enums_1.CleanupProcessMessage.RemoveCleanCommand,
             commandInfo,
         });
     }
     async addRequest(requestInfo) {
         const cleanupProcess = await this.getCleanupProcess();
         cleanupProcess.send({
-            messageType: "AddRequest" /* CleanupProcessMessage.AddRequest */,
+            messageType: detached_process_enums_1.CleanupProcessMessage.AddRequest,
             requestInfo,
         });
     }
     async removeRequest(requestInfo) {
         const cleanupProcess = await this.getCleanupProcess();
         cleanupProcess.send({
-            messageType: "RemoveRequest" /* CleanupProcessMessage.RemoveRequest */,
+            messageType: detached_process_enums_1.CleanupProcessMessage.RemoveRequest,
             requestInfo,
         });
     }
     async addCleanupDeleteAction(filePath) {
         const cleanupProcess = await this.getCleanupProcess();
         cleanupProcess.send({
-            messageType: "AddDeleteFileAction" /* CleanupProcessMessage.AddDeleteFileAction */,
+            messageType: detached_process_enums_1.CleanupProcessMessage.AddDeleteFileAction,
             filePath,
         });
     }
     async removeCleanupDeleteAction(filePath) {
         const cleanupProcess = await this.getCleanupProcess();
         cleanupProcess.send({
-            messageType: "RemoveDeleteFileAction" /* CleanupProcessMessage.RemoveDeleteFileAction */,
+            messageType: detached_process_enums_1.CleanupProcessMessage.RemoveDeleteFileAction,
             filePath,
         });
     }
     async addCleanupJS(jsCommand) {
         const cleanupProcess = await this.getCleanupProcess();
         cleanupProcess.send({
-            messageType: "AddJSFileToRequire" /* CleanupProcessMessage.AddJSFileToRequire */,
+            messageType: detached_process_enums_1.CleanupProcessMessage.AddJSFileToRequire,
             jsCommand,
         });
     }
     async removeCleanupJS(jsCommand) {
         const cleanupProcess = await this.getCleanupProcess();
         cleanupProcess.send({
-            messageType: "RemoveJSFileToRequire" /* CleanupProcessMessage.RemoveJSFileToRequire */,
+            messageType: detached_process_enums_1.CleanupProcessMessage.RemoveJSFileToRequire,
             jsCommand,
         });
     }
@@ -92,8 +93,6 @@ class CleanupService {
     setShouldDispose(shouldDispose) {
         this.shouldDispose = shouldDispose;
     }
-    // TODO: Consider extracting this method to a separate service
-    // as it has the same logic as the one used in analytics-service
     getCleanupProcess() {
         return new Promise((resolve, reject) => {
             const cleanupProcessArgs = this.getCleanupProcessArgs();
@@ -112,12 +111,11 @@ class CleanupService {
                 clearTimeout(timeoutId);
                 if (!isSettled) {
                     isSettled = true;
-                    // In case we throw error here, CLI will break its execution.
                     reject(err);
                 }
             });
             cleanupProcess.on("message", (data) => {
-                if (data === "ProcessReadyToReceive" /* DetachedProcessMessages.ProcessReadyToReceive */) {
+                if (data === detached_process_enums_1.DetachedProcessMessages.ProcessReadyToReceive) {
                     clearTimeout(timeoutId);
                     if (!isSettled) {
                         isSettled = true;
@@ -166,4 +164,3 @@ __decorate([
     (0, decorators_1.cache)()
 ], CleanupService.prototype, "getCleanupProcess", null);
 yok_1.injector.register("cleanupService", CleanupService);
-//# sourceMappingURL=cleanup-service.js.map