nativescript 9.0.0-alpha.0 → 9.0.0-alpha.10

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

@@ -0,0 +1,641 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BundlerCompilerService = void 0;
+const path = require("path");
+const semver = require("semver");
+const _ = require("lodash");
+const events_1 = require("events");
+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");
+const debugLog = false;
+class BundlerCompilerService extends events_1.EventEmitter {
+    constructor($options, $errors, $childProcess, $fs, $hooksService, $hostInfo, $logger, $mobileHelper, $cleanupService, $packageManager, $packageInstallationManager, $projectConfigService) {
+        super();
+        this.$options = $options;
+        this.$errors = $errors;
+        this.$childProcess = $childProcess;
+        this.$fs = $fs;
+        this.$hooksService = $hooksService;
+        this.$hostInfo = $hostInfo;
+        this.$logger = $logger;
+        this.$mobileHelper = $mobileHelper;
+        this.$cleanupService = $cleanupService;
+        this.$packageManager = $packageManager;
+        this.$packageInstallationManager = $packageInstallationManager;
+        this.$projectConfigService = $projectConfigService;
+        this.bundlerProcesses = {};
+        this.expectedHashes = {};
+    }
+    async compileWithWatch(platformData, projectData, prepareData) {
+        return new Promise(async (resolve, reject) => {
+            if (this.bundlerProcesses[platformData.platformNameLowerCase]) {
+                resolve(void 0);
+                return;
+            }
+            let isFirstBundlerWatchCompilation = true;
+            prepareData.watch = true;
+            try {
+                const childProcess = await this.startBundleProcess(platformData, projectData, prepareData);
+                const isVite = this.getBundler() === "vite";
+                childProcess.stdout.on("data", function (data) {
+                    process.stdout.write(data);
+                });
+                childProcess.stderr.on("data", function (data) {
+                    process.stderr.write(data);
+                });
+                childProcess.on("message", (message) => {
+                    this.$logger.trace(`Message from ${projectData.bundler}`, message);
+                    if (isVite &&
+                        message &&
+                        message.emittedFiles) {
+                        message = message;
+                        if (debugLog) {
+                            console.log("Received Vite IPC message:", message);
+                        }
+                        const distOutput = path.join(projectData.projectDir, "dist");
+                        const destDir = path.join(platformData.appDestinationDirectoryPath, this.$options.hostProjectModuleName);
+                        if (debugLog) {
+                            console.log(`🔥 Copying from ${distOutput} to ${destDir}`);
+                        }
+                        if (message.isHMR) {
+                            if (debugLog) {
+                                console.log("🔥 HMR update - copying only changed files for:", message.changedFiles);
+                            }
+                            let filesToCopy = message.emittedFiles;
+                            const hasHTMLChanges = message.changedFiles.some((f) => f.endsWith(".html"));
+                            if (hasHTMLChanges) {
+                                filesToCopy = message.emittedFiles.filter((f) => f.includes(".component") ||
+                                    f === "bundle.mjs" ||
+                                    f === "bundle.mjs.map");
+                                if (debugLog) {
+                                    console.log("🔥 HTML change detected - copying component files:", filesToCopy);
+                                }
+                            }
+                            this.copyViteBundleToNative(distOutput, destDir, filesToCopy);
+                        }
+                        else if (message.buildType === "incremental" &&
+                            message.changedFiles &&
+                            message.changedFiles.length > 0) {
+                            if (debugLog) {
+                                console.log("🔥 Incremental build - copying only relevant files for:", message.changedFiles);
+                            }
+                            const filesToCopy = this.getIncrementalFilesToCopy(message.emittedFiles, message.changedFiles);
+                            if (debugLog) {
+                                console.log("🔥 Incremental build - files to copy:", filesToCopy);
+                            }
+                            this.copyViteBundleToNative(distOutput, destDir, filesToCopy);
+                        }
+                        else if (message.buildType === "incremental" &&
+                            message.changedFiles &&
+                            message.changedFiles.length > 0) {
+                            console.log("🔥 Incremental build - copying only relevant files for:", message.changedFiles);
+                            const filesToCopy = this.getIncrementalFilesToCopy(message.emittedFiles, message.changedFiles);
+                            console.log("🔥 Incremental build - files to copy:", filesToCopy);
+                            this.copyViteBundleToNative(distOutput, destDir, filesToCopy);
+                        }
+                        else {
+                            if (debugLog) {
+                                console.log("🔥 Full build - copying all files");
+                            }
+                            this.copyViteBundleToNative(distOutput, destDir);
+                        }
+                        if (isFirstBundlerWatchCompilation) {
+                            isFirstBundlerWatchCompilation = false;
+                            if (debugLog) {
+                                console.log("Vite first build completed, resolving compileWithWatch");
+                            }
+                            resolve(childProcess);
+                        }
+                        const files = message.emittedFiles.map((file) => path.join(platformData.appDestinationDirectoryPath, this.$options.hostProjectModuleName, file));
+                        const data = {
+                            files,
+                            hasOnlyHotUpdateFiles: message.isHMR || false,
+                            hmrData: {
+                                hash: message.hash || "",
+                                fallbackFiles: [],
+                            },
+                            platform: platformData.platformNameLowerCase,
+                        };
+                        this.$logger.info(`Vite build completed! Files copied to native platform.`);
+                        this.notifyHMRClients({
+                            type: message.isHMR ? "js-update" : "build-complete",
+                            timestamp: Date.now(),
+                            changedFiles: message.changedFiles || [],
+                            buildType: message.buildType || "incremental",
+                            isHMR: message.isHMR || false,
+                        });
+                        if (message.isHMR) {
+                            if (debugLog) {
+                                console.log("🔥 Skipping BUNDLER_COMPILATION_COMPLETE for HMR update - app will not restart");
+                            }
+                        }
+                        else {
+                            if (debugLog) {
+                                console.log("🔥 Emitting BUNDLER_COMPILATION_COMPLETE for full build");
+                            }
+                            this.emit(constants_1.BUNDLER_COMPILATION_COMPLETE, data);
+                        }
+                        return;
+                    }
+                    if (typeof message === "object" &&
+                        "version" in message &&
+                        "type" in message) {
+                        if (isFirstBundlerWatchCompilation) {
+                            isFirstBundlerWatchCompilation = false;
+                            resolve(childProcess);
+                            return;
+                        }
+                        return this.handleHMRMessage(message, platformData, projectData, prepareData);
+                    }
+                    if (message ===
+                        `${capitalizeFirstLetter(projectData.bundler)} compilation complete.`) {
+                        this.$logger.info(`${capitalizeFirstLetter(projectData.bundler)} build done!`);
+                        resolve(childProcess);
+                    }
+                    message = message;
+                    if (message.emittedFiles) {
+                        if (isFirstBundlerWatchCompilation) {
+                            isFirstBundlerWatchCompilation = false;
+                            this.expectedHashes[platformData.platformNameLowerCase] =
+                                prepareData.hmr ? message.hash : "";
+                            return;
+                        }
+                        const previousHash = this.expectedHashes[platformData.platformNameLowerCase];
+                        let result;
+                        if (prepareData.hmr) {
+                            result = this.getUpdatedEmittedFiles(message.emittedFiles, message.chunkFiles, message.hash, platformData.platformNameLowerCase);
+                        }
+                        else {
+                            result = {
+                                emittedFiles: message.emittedFiles,
+                                fallbackFiles: [],
+                                hash: "",
+                            };
+                        }
+                        const files = result.emittedFiles.map((file) => path.join(platformData.appDestinationDirectoryPath, this.$options.hostProjectModuleName, file));
+                        const fallbackFiles = result.fallbackFiles.map((file) => path.join(platformData.appDestinationDirectoryPath, this.$options.hostProjectModuleName, file));
+                        const data = {
+                            files,
+                            hasOnlyHotUpdateFiles: files.every((f) => f.indexOf("hot-update") > -1),
+                            hmrData: {
+                                hash: result.hash,
+                                fallbackFiles,
+                            },
+                            platform: platformData.platformNameLowerCase,
+                        };
+                        this.$logger.trace(`Generated data from ${projectData.bundler} message:`, data);
+                        if (data.hasOnlyHotUpdateFiles && previousHash === message.hash) {
+                            return;
+                        }
+                        if (data.files.length) {
+                            this.emit(constants_1.BUNDLER_COMPILATION_COMPLETE, data);
+                        }
+                    }
+                });
+                childProcess.on("error", (err) => {
+                    this.$logger.trace(`Unable to start ${projectData.bundler} process in watch mode. Error is: ${err}`);
+                    delete this.bundlerProcesses[platformData.platformNameLowerCase];
+                    reject(err);
+                });
+                childProcess.on("close", async (arg) => {
+                    const exitCode = typeof arg === "number" ? arg : arg && arg.code;
+                    this.$logger.trace(`${capitalizeFirstLetter(projectData.bundler)} process exited with code ${exitCode} when we expected it to be long living with watch.`);
+                    await this.$cleanupService.removeKillProcess(childProcess.pid.toString());
+                    const error = new Error(`Executing ${projectData.bundler} failed with exit code ${exitCode}.`);
+                    error.code = exitCode;
+                    delete this.bundlerProcesses[platformData.platformNameLowerCase];
+                    reject(error);
+                });
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+    }
+    async compileWithoutWatch(platformData, projectData, prepareData) {
+        return new Promise(async (resolve, reject) => {
+            if (this.bundlerProcesses[platformData.platformNameLowerCase]) {
+                resolve();
+                return;
+            }
+            try {
+                const childProcess = await this.startBundleProcess(platformData, projectData, prepareData);
+                childProcess.on("error", (err) => {
+                    this.$logger.trace(`Unable to start ${projectData.bundler} process in non-watch mode. Error is: ${err}`);
+                    delete this.bundlerProcesses[platformData.platformNameLowerCase];
+                    reject(err);
+                });
+                childProcess.on("close", async (arg) => {
+                    await this.$cleanupService.removeKillProcess(childProcess.pid.toString());
+                    delete this.bundlerProcesses[platformData.platformNameLowerCase];
+                    const exitCode = typeof arg === "number" ? arg : arg && arg.code;
+                    if (exitCode === 0) {
+                        resolve();
+                    }
+                    else {
+                        const error = new Error(`Executing ${projectData.bundler} failed with exit code ${exitCode}.`);
+                        error.code = exitCode;
+                        reject(error);
+                    }
+                });
+            }
+            catch (err) {
+                reject(err);
+            }
+        });
+    }
+    async stopBundlerCompiler(platform) {
+        if (platform) {
+            await this.stopBundlerForPlatform(platform);
+        }
+        else {
+            const bundlerPlatforms = Object.keys(this.bundlerProcesses);
+            for (let i = 0; i < bundlerPlatforms.length; i++) {
+                await this.stopBundlerForPlatform(bundlerPlatforms[i]);
+            }
+        }
+    }
+    async shouldUsePreserveSymlinksOption() {
+        const currentPackageManager = await this.$packageManager.getPackageManagerName();
+        const res = currentPackageManager !== constants_1.PackageManagers.pnpm;
+        return res;
+    }
+    async startBundleProcess(platformData, projectData, prepareData) {
+        if (projectData.bundlerConfigPath) {
+            if (!this.$fs.exists(projectData.bundlerConfigPath)) {
+                this.$errors.fail(`The bundler configuration file ${projectData.bundlerConfigPath} does not exist. Ensure the file exists, or update the path in ${constants_1.CONFIG_FILE_NAME_DISPLAY}.`);
+            }
+        }
+        else {
+            if (!this.$fs.exists(projectData.bundlerConfigPath)) {
+                this.$errors.fail(`The ${projectData.bundler} configuration file ${projectData.bundlerConfigPath} does not exist. Ensure the file exists, or update the path in ${constants_1.CONFIG_FILE_NAME_DISPLAY}.`);
+            }
+        }
+        const envData = this.buildEnvData(platformData.platformNameLowerCase, projectData, prepareData);
+        const isVite = this.getBundler() === "vite";
+        const cliArgs = await this.buildEnvCommandLineParams(envData, platformData, projectData, prepareData);
+        const envParams = isVite
+            ? [
+                `--mode=${platformData.platformNameLowerCase}`,
+                `--watch`,
+                "--",
+                ...cliArgs,
+            ]
+            : cliArgs;
+        const additionalNodeArgs = semver.major(process.version) <= 8 ? ["--harmony"] : [];
+        if (await this.shouldUsePreserveSymlinksOption()) {
+            additionalNodeArgs.push("--preserve-symlinks");
+        }
+        if (process.arch === "x64") {
+            additionalNodeArgs.unshift("--max_old_space_size=4096");
+        }
+        const args = [
+            ...additionalNodeArgs,
+            this.getBundlerExecutablePath(projectData),
+            isVite ? "build" : this.isModernBundler(projectData) ? `build` : null,
+            `--config=${projectData.bundlerConfigPath}`,
+            ...envParams,
+        ].filter(Boolean);
+        if (!isVite) {
+            if (prepareData.watch) {
+                args.push("--watch");
+            }
+        }
+        const stdio = prepareData.watch || isVite ? ["ipc"] : "inherit";
+        const options = {
+            cwd: projectData.projectDir,
+            stdio,
+        };
+        options.env = {
+            ...process.env,
+            NATIVESCRIPT_WEBPACK_ENV: JSON.stringify(envData),
+            NATIVESCRIPT_BUNDLER_ENV: JSON.stringify(envData),
+        };
+        if (this.$hostInfo.isWindows) {
+            Object.assign(options.env, { APPDATA: process.env.appData });
+        }
+        if (this.$options.hostProjectPath) {
+            Object.assign(options.env, {
+                USER_PROJECT_PLATFORMS_ANDROID: this.$options.hostProjectPath,
+                USER_PROJECT_PLATFORMS_ANDROID_MODULE: this.$options.hostProjectModuleName,
+                USER_PROJECT_PLATFORMS_IOS: this.$options.hostProjectPath,
+            });
+        }
+        if (debugLog) {
+            console.log("args:", args);
+        }
+        const childProcess = this.$childProcess.spawn(process.execPath, args, options);
+        this.bundlerProcesses[platformData.platformNameLowerCase] = childProcess;
+        await this.$cleanupService.addKillProcess(childProcess.pid.toString());
+        return childProcess;
+    }
+    buildEnvData(platform, projectData, prepareData) {
+        var _a, _b, _c;
+        const { env } = prepareData;
+        const envData = Object.assign({}, env, { [platform.toLowerCase()]: true });
+        const appId = projectData.projectIdentifiers[platform];
+        const appPath = projectData.getAppDirectoryRelativePath();
+        const appResourcesPath = projectData.getAppResourcesRelativeDirectoryPath();
+        Object.assign(envData, appId && { appId }, appPath && { appPath }, appResourcesPath && { appResourcesPath }, {
+            nativescriptLibPath: path.resolve(__dirname, "..", "..", "nativescript-cli-lib.js"),
+        });
+        envData.verbose = envData.verbose || this.$logger.isVerbose();
+        envData.production = envData.production || prepareData.release;
+        envData.config =
+            (_b = (_a = process.env.NATIVESCRIPT_CONFIG_NAME) !== null && _a !== void 0 ? _a : this.$options.config) !== null && _b !== void 0 ? _b : "false";
+        process.env.NATIVESCRIPT_CONFIG_NAME = envData.config;
+        envData.skipSnapshotTools =
+            prepareData.nativePrepare && prepareData.nativePrepare.skipNativePrepare;
+        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;
+            }
+        }
+        if (envData.sourceMap === "true" || envData.sourceMap === "false") {
+            envData.sourceMap = envData.sourceMap === "true";
+        }
+        if (prepareData.uniqueBundle > 0) {
+            envData.uniqueBundle = prepareData.uniqueBundle;
+        }
+        return envData;
+    }
+    async buildEnvCommandLineParams(envData, platformData, projectData, prepareData) {
+        const envFlagNames = Object.keys(envData);
+        const canSnapshot = prepareData.release &&
+            this.$mobileHelper.isAndroidPlatform(platformData.normalizedPlatformName);
+        if (envData && envData.snapshot) {
+            if (!canSnapshot) {
+                this.$logger.warn("Stripping the snapshot flag. " +
+                    "Bear in mind that snapshot is only available in Android release builds.");
+                envFlagNames.splice(envFlagNames.indexOf("snapshot"), 1);
+            }
+            else if (this.$hostInfo.isWindows) {
+                if (projectData.bundler === "webpack") {
+                    const minWebpackPluginWithWinSnapshotsVersion = "1.3.0";
+                    const installedWebpackPluginVersion = await this.$packageInstallationManager.getInstalledDependencyVersion(constants_1.WEBPACK_PLUGIN_NAME, projectData.projectDir);
+                    const hasWebpackPluginWithWinSnapshotsSupport = !!installedWebpackPluginVersion
+                        ? semver.gte(semver.coerce(installedWebpackPluginVersion), minWebpackPluginWithWinSnapshotsVersion)
+                        : true;
+                    if (!hasWebpackPluginWithWinSnapshotsSupport) {
+                        this.$errors.fail(`In order to generate Snapshots on Windows, please upgrade your Webpack plugin version (npm i ${constants_1.WEBPACK_PLUGIN_NAME}@latest).`);
+                    }
+                }
+            }
+        }
+        const args = [];
+        envFlagNames.map((item) => {
+            let envValue = envData[item];
+            if (typeof envValue === "undefined") {
+                return;
+            }
+            if (typeof envValue === "boolean") {
+                if (envValue) {
+                    args.push(`--env.${item}`);
+                }
+            }
+            else {
+                if (!Array.isArray(envValue)) {
+                    envValue = [envValue];
+                }
+                envValue.map((value) => args.push(`--env.${item}=${value}`));
+            }
+        });
+        return args;
+    }
+    getUpdatedEmittedFiles(allEmittedFiles, chunkFiles, nextHash, platform) {
+        const currentHash = this.getCurrentHotUpdateHash(allEmittedFiles);
+        const isHashValid = nextHash
+            ? this.expectedHashes[platform] === currentHash
+            : true;
+        this.expectedHashes[platform] = nextHash;
+        const emittedHotUpdatesAndAssets = isHashValid
+            ? _.difference(allEmittedFiles, chunkFiles)
+            : allEmittedFiles;
+        const fallbackFiles = chunkFiles.concat(emittedHotUpdatesAndAssets.filter((f) => f.indexOf("hot-update") === -1));
+        return {
+            emittedFiles: emittedHotUpdatesAndAssets,
+            fallbackFiles,
+            hash: currentHash,
+        };
+    }
+    getCurrentHotUpdateHash(emittedFiles) {
+        let hotHash;
+        const hotUpdateScripts = emittedFiles.filter((x) => x.endsWith(".hot-update.js"));
+        if (hotUpdateScripts && hotUpdateScripts.length) {
+            const hotUpdateName = hotUpdateScripts[0];
+            const matcher = /^(.+)\.(.+)\.hot-update/gm;
+            const matches = matcher.exec(hotUpdateName);
+            hotHash = matches[2];
+        }
+        return hotHash || "";
+    }
+    async stopBundlerForPlatform(platform) {
+        this.$logger.trace(`Stopping ${this.getBundler()} watch for platform ${platform}.`);
+        const bundlerProcess = this.bundlerProcesses[platform];
+        await this.$cleanupService.removeKillProcess(bundlerProcess.pid.toString());
+        if (bundlerProcess) {
+            bundlerProcess.kill("SIGINT");
+            delete this.bundlerProcesses[platform];
+        }
+    }
+    handleHMRMessage(message, platformData, projectData, prepareData) {
+        this.$logger.trace(`Received message from ${projectData.bundler} process:`, message);
+        if (message.type !== "compilation") {
+            return;
+        }
+        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));
+        const lastHash = (() => {
+            const absoluteFileNameWithLastHash = files.find((fileName) => fileName.endsWith("hot-update.js"));
+            if (!absoluteFileNameWithLastHash) {
+                return null;
+            }
+            const fileNameWithLastHash = path.basename(absoluteFileNameWithLastHash);
+            const matches = fileNameWithLastHash.match(/\.(.+).hot-update\.js/);
+            if (matches) {
+                return matches[1];
+            }
+        })();
+        if (!files.length) {
+            return;
+        }
+        this.emit(constants_1.BUNDLER_COMPILATION_COMPLETE, {
+            files,
+            staleFiles,
+            hasOnlyHotUpdateFiles: prepareData.hmr,
+            hmrData: {
+                hash: lastHash || message.hash,
+                fallbackFiles: [],
+            },
+            platform: platformData.platformNameLowerCase,
+        });
+    }
+    getBundlerExecutablePath(projectData) {
+        const bundler = this.getBundler();
+        if (bundler === "vite") {
+            const packagePath = (0, package_path_helper_1.resolvePackagePath)(`vite`, {
+                paths: [projectData.projectDir],
+            });
+            if (packagePath) {
+                return path.resolve(packagePath, "bin", "vite.js");
+            }
+        }
+        else if (this.isModernBundler(projectData)) {
+            const packagePath = (0, package_path_helper_1.resolvePackagePath)(`@nativescript/${bundler}`, {
+                paths: [projectData.projectDir],
+            });
+            if (packagePath) {
+                return path.resolve(packagePath, "dist", "bin", "index.js");
+            }
+        }
+        const packagePath = (0, package_path_helper_1.resolvePackagePath)("webpack", {
+            paths: [projectData.projectDir],
+        });
+        if (!packagePath) {
+            return "";
+        }
+        return path.resolve(packagePath, "bin", "webpack.js");
+    }
+    isModernBundler(projectData) {
+        const bundler = this.getBundler();
+        switch (bundler) {
+            case "rspack":
+                return true;
+            default:
+                const packageJSONPath = (0, package_path_helper_1.resolvePackageJSONPath)(constants_1.WEBPACK_PLUGIN_NAME, {
+                    paths: [projectData.projectDir],
+                });
+                if (packageJSONPath) {
+                    const packageData = this.$fs.readJson(packageJSONPath);
+                    const ver = semver.coerce(packageData.version);
+                    if (semver.satisfies(ver, ">= 5.0.0")) {
+                        return true;
+                    }
+                }
+                break;
+        }
+        return false;
+    }
+    getBundler() {
+        return this.$projectConfigService.getValue(`bundler`, "webpack");
+    }
+    copyViteBundleToNative(distOutput, destDir, specificFiles = null) {
+        if (debugLog) {
+            console.log(`Copying Vite bundle from "${distOutput}" to "${destDir}"`);
+        }
+        const fs = require("fs");
+        try {
+            if (specificFiles) {
+                if (debugLog) {
+                    console.log("🔥 Selective copy - copying specific files:", specificFiles);
+                }
+                fs.mkdirSync(destDir, { recursive: true });
+                for (const file of specificFiles) {
+                    const srcPath = path.join(distOutput, file);
+                    const destPath = path.join(destDir, file);
+                    if (!fs.existsSync(srcPath))
+                        continue;
+                    fs.mkdirSync(path.dirname(destPath), { recursive: true });
+                    fs.copyFileSync(srcPath, destPath);
+                    if (debugLog) {
+                        console.log(`🔥 Copied ${file}`);
+                    }
+                }
+            }
+            else {
+                if (debugLog) {
+                    console.log("🔥 Full build: Copying all files");
+                }
+                if (fs.existsSync(destDir)) {
+                    fs.rmSync(destDir, { recursive: true, force: true });
+                }
+                fs.mkdirSync(destDir, { recursive: true });
+                if (fs.existsSync(distOutput)) {
+                    this.copyRecursiveSync(distOutput, destDir, fs);
+                }
+                else {
+                    this.$logger.warn(`Vite output directory does not exist: ${distOutput}`);
+                }
+            }
+        }
+        catch (error) {
+            this.$logger.warn(`Failed to copy Vite bundle: ${error.message}`);
+        }
+    }
+    getIncrementalFilesToCopy(emittedFiles, changedFiles) {
+        const filesToCopy = [];
+        const bundleFiles = emittedFiles.filter((file) => !file.includes("vendor") &&
+            (file.includes("bundle") ||
+                file.includes("main") ||
+                file.includes("app") ||
+                file.endsWith(".mjs") ||
+                file.endsWith(".js")));
+        filesToCopy.push(...bundleFiles);
+        const sourceMapFiles = emittedFiles.filter((file) => !file.includes("vendor") && file.endsWith(".map"));
+        filesToCopy.push(...sourceMapFiles);
+        const hasAssetChanges = changedFiles.some((file) => file.includes("/assets/") ||
+            file.includes("/static/") ||
+            file.includes("/public/"));
+        if (hasAssetChanges) {
+            const assetFiles = emittedFiles.filter((file) => file.includes("assets/") ||
+                file.includes("static/") ||
+                file.includes("fonts/") ||
+                file.includes("images/"));
+            filesToCopy.push(...assetFiles);
+        }
+        return [...new Set(filesToCopy)];
+    }
+    notifyHMRClients(message) {
+        try {
+            const WebSocket = require("ws");
+            const ws = new WebSocket("ws://localhost:24678");
+            ws.on("open", () => {
+                if (debugLog) {
+                    console.log("🔥 Sending HMR notification to bridge:", message.type);
+                }
+                ws.send(JSON.stringify(message));
+                ws.close();
+            });
+            ws.on("error", () => {
+                if (debugLog) {
+                    console.log("🔥 HMR bridge not available (this is normal without HMR)");
+                }
+            });
+        }
+        catch (error) {
+            if (debugLog) {
+                console.log("🔥 WebSocket not available for HMR notifications");
+            }
+        }
+    }
+    copyRecursiveSync(src, dest, fs) {
+        for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+            const srcPath = path.join(src, entry.name);
+            const destPath = path.join(dest, entry.name);
+            if (entry.isDirectory()) {
+                fs.mkdirSync(destPath, { recursive: true });
+                this.copyRecursiveSync(srcPath, destPath, fs);
+            }
+            else if (entry.isFile() || entry.isSymbolicLink()) {
+                fs.copyFileSync(srcPath, destPath);
+            }
+        }
+    }
+}
+exports.BundlerCompilerService = BundlerCompilerService;
+__decorate([
+    (0, decorators_1.performanceLog)()
+], BundlerCompilerService.prototype, "startBundleProcess", null);
+function capitalizeFirstLetter(val) {
+    return String(val).charAt(0).toUpperCase() + String(val).slice(1);
+}
+yok_1.injector.register("bundlerCompilerService", BundlerCompilerService);

package/lib/services/bundler/bundler.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SPMService = void 0;
 const yok_1 = require("../../common/yok");
-const trapezedev_project_1 = require("@rigor789/trapezedev-project");
+const trapezedev_project_1 = require("@nstudio/trapezedev-project");
 const path = require("path");
 class SPMService {
     constructor($logger, $projectConfigService, $xcodebuildCommandService, $xcodebuildArgsService) {

package/lib/services/livesync/android-livesync-tool.js

@@ -292,7 +292,9 @@ class AndroidLivesyncTool {
                     socket.removeAllListeners();
                     this.pendingConnectionData.socketTimer = setTimeout(tryConnect, 1000);
                 };
-                this.pendingConnectionData.socket = socket;
+                if (this.pendingConnectionData) {
+                    this.pendingConnectionData.socket = socket;
+                }
                 socket.once("data", (data) => {
                     socket.removeListener("close", tryConnectAfterTimeout);
                     socket.removeListener("error", tryConnectAfterTimeout);