@akylas/nativescript-cli 8.9.4 → 8.10.0

package/lib/services/android/gradle-build-service.js

@@ -17,7 +17,10 @@ class GradleBuildService extends events_1.EventEmitter {
         const buildTaskArgs = await this.$gradleBuildArgsService.getBuildTaskArgs(buildData);
         if (buildData.buildFilterDevicesArch) {
             let devices = this.$devicesService.getDevicesForPlatform(buildData.platform);
-            if (buildData.emulator) {
+            if (buildData.device) {
+                devices = devices.filter((d) => d.deviceInfo.identifier === buildData.device);
+            }
+            else if (buildData.emulator) {
                 devices = devices.filter((d) => d.isEmulator);
             }
             const abis = devices

package/lib/services/android-project-service.js

@@ -448,17 +448,19 @@ class AndroidProjectService extends projectServiceBaseLib.PlatformProjectService
                 if (!this.$fs.exists(apkOutputPath)) {
                     return;
                 }
-                const device = this.$devicesService
-                    .getDevicesForPlatform(deviceDescriptor.buildData.platform)
-                    .filter((d) => d.deviceInfo.identifier === deviceDescriptor.identifier)[0];
-                const abis = device.deviceInfo.abis.filter((a) => !!a && a.length)[0];
                 const directoryContent = this.$fs.readDirectory(apkOutputPath);
-                const regexp = new RegExp(`${abis}.*\.apk`);
-                const files = _.filter(directoryContent, (entry) => {
-                    return regexp.test(entry);
-                });
-                if (files.length === 0) {
-                    changesInfo.nativeChanged = true;
+                if (!directoryContent.find(f => f.indexOf("universal") !== -1)) {
+                    const device = this.$devicesService
+                        .getDevicesForPlatform(deviceDescriptor.buildData.platform)
+                        .filter((d) => d.deviceInfo.identifier === deviceDescriptor.identifier)[0];
+                    const abis = device.deviceInfo.abis.filter((a) => !!a && a.length)[0];
+                    const regexp = new RegExp(`${abis}.*\.apk`);
+                    const files = _.filter(directoryContent, (entry) => {
+                        return regexp.test(entry);
+                    });
+                    if (files.length === 0) {
+                        changesInfo.nativeChanged = true;
+                    }
                 }
             }
         });

package/lib/services/{webpack/webpack-compiler-service.js → bundler/bundler-compiler-service.js}

@@ -6,7 +6,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WebpackCompilerService = void 0;
+exports.BundlerCompilerService = void 0;
 const path = require("path");
 const semver = require("semver");
 const _ = require("lodash");
@@ -15,8 +15,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");
-class WebpackCompilerService extends events_1.EventEmitter {
-    constructor($options, $errors, $childProcess, $fs, $hooksService, $hostInfo, $logger, $mobileHelper, $cleanupService, $packageManager, $packageInstallationManager) {
+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;
@@ -29,19 +30,21 @@ class WebpackCompilerService extends events_1.EventEmitter {
         this.$cleanupService = $cleanupService;
         this.$packageManager = $packageManager;
         this.$packageInstallationManager = $packageInstallationManager;
-        this.webpackProcesses = {};
+        this.$projectConfigService = $projectConfigService;
+        this.bundlerProcesses = {};
         this.expectedHashes = {};
     }
     async compileWithWatch(platformData, projectData, prepareData) {
         return new Promise(async (resolve, reject) => {
-            if (this.webpackProcesses[platformData.platformNameLowerCase]) {
+            if (this.bundlerProcesses[platformData.platformNameLowerCase]) {
                 resolve(void 0);
                 return;
             }
-            let isFirstWebpackWatchCompilation = true;
+            let isFirstBundlerWatchCompilation = true;
             prepareData.watch = true;
             try {
-                const childProcess = await this.startWebpackProcess(platformData, projectData, prepareData);
+                const childProcess = await this.startBundleProcess(platformData, projectData, prepareData);
+                const isVite = this.getBundler() === "vite";
                 childProcess.stdout.on("data", function (data) {
                     process.stdout.write(data);
                 });
@@ -49,25 +52,77 @@ class WebpackCompilerService extends events_1.EventEmitter {
                     process.stderr.write(data);
                 });
                 childProcess.on("message", (message) => {
-                    this.$logger.trace("Message from webpack", 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, ".ns-vite-build");
+                        const destDir = path.join(platformData.appDestinationDirectoryPath, this.$options.hostProjectModuleName);
+                        if (debugLog) {
+                            console.log(`Copying from ${distOutput} to ${destDir}.`);
+                        }
+                        if (message.buildType === "incremental" &&
+                            message.emittedFiles &&
+                            message.emittedFiles.length > 0) {
+                            const filesToCopy = this.getIncrementalFilesToCopy(message.emittedFiles);
+                            if (debugLog) {
+                                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.`);
+                        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 (isFirstWebpackWatchCompilation) {
-                            isFirstWebpackWatchCompilation = false;
+                        if (isFirstBundlerWatchCompilation) {
+                            isFirstBundlerWatchCompilation = false;
                             resolve(childProcess);
                             return;
                         }
                         return this.handleHMRMessage(message, platformData, projectData, prepareData);
                     }
-                    if (message === "Webpack compilation complete.") {
-                        this.$logger.info("Webpack build done!");
+                    if (message ===
+                        `${capitalizeFirstLetter(projectData.bundler)} compilation complete.`) {
+                        this.$logger.info(`${capitalizeFirstLetter(projectData.bundler)} build done!`);
                         resolve(childProcess);
                     }
                     message = message;
                     if (message.emittedFiles) {
-                        if (isFirstWebpackWatchCompilation) {
-                            isFirstWebpackWatchCompilation = false;
+                        if (isFirstBundlerWatchCompilation) {
+                            isFirstBundlerWatchCompilation = false;
                             this.expectedHashes[platformData.platformNameLowerCase] =
                                 prepareData.hmr ? message.hash : "";
                             return;
@@ -95,27 +150,27 @@ class WebpackCompilerService extends events_1.EventEmitter {
                             },
                             platform: platformData.platformNameLowerCase,
                         };
-                        this.$logger.trace("Generated data from webpack message:", data);
+                        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.WEBPACK_COMPILATION_COMPLETE, data);
+                            this.emit(constants_1.BUNDLER_COMPILATION_COMPLETE, data);
                         }
                     }
                 });
                 childProcess.on("error", (err) => {
-                    this.$logger.trace(`Unable to start webpack process in watch mode. Error is: ${err}`);
-                    delete this.webpackProcesses[platformData.platformNameLowerCase];
+                    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) => {
-                    await this.$cleanupService.removeKillProcess(childProcess.pid.toString());
                     const exitCode = typeof arg === "number" ? arg : arg && arg.code;
-                    this.$logger.trace(`Webpack process exited with code ${exitCode} when we expected it to be long living with watch.`);
-                    const error = new Error(`Executing webpack failed with exit code ${exitCode}.`);
+                    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.webpackProcesses[platformData.platformNameLowerCase];
+                    delete this.bundlerProcesses[platformData.platformNameLowerCase];
                     reject(error);
                 });
             }
@@ -126,26 +181,26 @@ class WebpackCompilerService extends events_1.EventEmitter {
     }
     async compileWithoutWatch(platformData, projectData, prepareData) {
         return new Promise(async (resolve, reject) => {
-            if (this.webpackProcesses[platformData.platformNameLowerCase]) {
+            if (this.bundlerProcesses[platformData.platformNameLowerCase]) {
                 resolve();
                 return;
             }
             try {
-                const childProcess = await this.startWebpackProcess(platformData, projectData, prepareData);
+                const childProcess = await this.startBundleProcess(platformData, projectData, prepareData);
                 childProcess.on("error", (err) => {
-                    this.$logger.trace(`Unable to start webpack process in non-watch mode. Error is: ${err}`);
-                    delete this.webpackProcesses[platformData.platformNameLowerCase];
+                    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.webpackProcesses[platformData.platformNameLowerCase];
+                    delete this.bundlerProcesses[platformData.platformNameLowerCase];
                     const exitCode = typeof arg === "number" ? arg : arg && arg.code;
                     if (exitCode === 0) {
                         resolve();
                     }
                     else {
-                        const error = new Error(`Executing webpack failed with exit code ${exitCode}.`);
+                        const error = new Error(`Executing ${projectData.bundler} failed with exit code ${exitCode}.`);
                         error.code = exitCode;
                         reject(error);
                     }
@@ -156,14 +211,14 @@ class WebpackCompilerService extends events_1.EventEmitter {
             }
         });
     }
-    async stopWebpackCompiler(platform) {
+    async stopBundlerCompiler(platform) {
         if (platform) {
-            await this.stopWebpackForPlatform(platform);
+            await this.stopBundlerForPlatform(platform);
         }
         else {
-            const webpackedPlatforms = Object.keys(this.webpackProcesses);
-            for (let i = 0; i < webpackedPlatforms.length; i++) {
-                await this.stopWebpackForPlatform(webpackedPlatforms[i]);
+            const bundlerPlatforms = Object.keys(this.bundlerProcesses);
+            for (let i = 0; i < bundlerPlatforms.length; i++) {
+                await this.stopBundlerForPlatform(bundlerPlatforms[i]);
             }
         }
     }
@@ -172,12 +227,28 @@ class WebpackCompilerService extends events_1.EventEmitter {
         const res = currentPackageManager !== constants_1.PackageManagers.pnpm;
         return res;
     }
-    async startWebpackProcess(platformData, projectData, prepareData) {
-        if (!this.$fs.exists(projectData.webpackConfigPath)) {
-            this.$errors.fail(`The webpack configuration file ${projectData.webpackConfigPath} does not exist. Ensure the file exists, or update the path in ${constants_1.CONFIG_FILE_NAME_DISPLAY}.`);
+    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 envParams = await this.buildEnvCommandLineParams(envData, platformData, projectData, prepareData);
+        const isVite = this.getBundler() === "vite";
+        const cliArgs = await this.buildEnvCommandLineParams(envData, platformData, projectData, prepareData);
+        const envParams = isVite
+            ? [
+                `--mode=${prepareData.release ? "production" : "development"}`,
+                `--watch`,
+                "--",
+                ...cliArgs,
+            ]
+            : cliArgs;
         const additionalNodeArgs = semver.major(process.version) <= 8 ? ["--harmony"] : [];
         if (await this.shouldUsePreserveSymlinksOption()) {
             additionalNodeArgs.push("--preserve-symlinks");
@@ -187,15 +258,17 @@ class WebpackCompilerService extends events_1.EventEmitter {
         }
         const args = [
             ...additionalNodeArgs,
-            this.getWebpackExecutablePath(projectData),
-            this.isWebpack5(projectData) ? `build` : null,
-            `--config=${projectData.webpackConfigPath}`,
+            this.getBundlerExecutablePath(projectData),
+            isVite || this.isModernBundler(projectData) ? "build" : null,
+            `--config=${projectData.bundlerConfigPath}`,
             ...envParams,
         ].filter(Boolean);
-        if (prepareData.watch) {
-            args.push("--watch");
+        if (!isVite) {
+            if (prepareData.watch) {
+                args.push("--watch");
+            }
         }
-        const stdio = prepareData.watch ? ["ipc"] : "inherit";
+        const stdio = prepareData.watch || isVite ? ["ipc"] : "inherit";
         const options = {
             cwd: projectData.projectDir,
             stdio,
@@ -203,6 +276,7 @@ class WebpackCompilerService extends events_1.EventEmitter {
         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 });
@@ -214,8 +288,11 @@ class WebpackCompilerService extends events_1.EventEmitter {
                 USER_PROJECT_PLATFORMS_IOS: this.$options.hostProjectPath,
             });
         }
+        if (debugLog) {
+            console.log("args:", args);
+        }
         const childProcess = this.$childProcess.spawn(process.execPath, args, options);
-        this.webpackProcesses[platformData.platformNameLowerCase] = childProcess;
+        this.bundlerProcesses[platformData.platformNameLowerCase] = childProcess;
         await this.$cleanupService.addKillProcess(childProcess.pid.toString());
         return childProcess;
     }
@@ -261,13 +338,15 @@ class WebpackCompilerService extends events_1.EventEmitter {
                 envFlagNames.splice(envFlagNames.indexOf("snapshot"), 1);
             }
             else if (this.$hostInfo.isWindows) {
-                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).`);
+                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).`);
+                    }
                 }
             }
         }
@@ -318,21 +397,21 @@ class WebpackCompilerService extends events_1.EventEmitter {
         }
         return hotHash || "";
     }
-    async stopWebpackForPlatform(platform) {
-        this.$logger.trace(`Stopping webpack watch for platform ${platform}.`);
-        const webpackProcess = this.webpackProcesses[platform];
-        await this.$cleanupService.removeKillProcess(webpackProcess.pid.toString());
-        if (webpackProcess) {
-            webpackProcess.kill("SIGINT");
-            delete this.webpackProcesses[platform];
+    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 webpack process:", message);
+        this.$logger.trace(`Received message from ${projectData.bundler} process:`, message);
         if (message.type !== "compilation") {
             return;
         }
-        this.$logger.trace("Webpack build done!");
+        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 = (() => {
@@ -349,7 +428,7 @@ class WebpackCompilerService extends events_1.EventEmitter {
         if (!files.length) {
             return;
         }
-        this.emit(constants_1.WEBPACK_COMPILATION_COMPLETE, {
+        this.emit(constants_1.BUNDLER_COMPILATION_COMPLETE, {
             files,
             staleFiles,
             hasOnlyHotUpdateFiles: prepareData.hmr,
@@ -360,41 +439,131 @@ class WebpackCompilerService extends events_1.EventEmitter {
             platform: platformData.platformNameLowerCase,
         });
     }
-    getWebpackExecutablePath(projectData) {
-        if (this.isWebpack5(projectData)) {
-            const packageName = projectData.nsConfig.webpackPackageName || constants_1.WEBPACK_PLUGIN_NAME;
-            let packagePath = (0, package_path_helper_1.resolvePackagePath)(packageName, {
+    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, "dist", "bin", "index.js");
+                return path.resolve(packagePath, "bin", "vite.js");
             }
         }
-        const packagePath = (0, package_path_helper_1.resolvePackagePath)("webpack", {
-            paths: [projectData.projectDir],
-        });
-        if (!packagePath) {
-            return "";
+        else if (this.isModernBundler(projectData)) {
+            const webpackPluginName = this.$projectConfigService.getValue(`webpackPackageName`, constants_1.WEBPACK_PLUGIN_NAME);
+            const packagePath = (0, package_path_helper_1.resolvePackagePath)(webpackPluginName, {
+                paths: [projectData.projectDir],
+            });
+            if (packagePath) {
+                return path.resolve(packagePath, "dist", "bin", "index.js");
+            }
         }
-        return path.resolve(packagePath, "bin", "webpack.js");
+        throw new Error('could not find bundler executable');
     }
-    isWebpack5(projectData) {
-        const packageName = projectData.nsConfig.webpackPackageName || constants_1.WEBPACK_PLUGIN_NAME;
-        const packageJSONPath = (0, package_path_helper_1.resolvePackageJSONPath)(packageName, {
-            paths: [projectData.projectDir],
-        });
-        if (packageJSONPath) {
-            const packageData = this.$fs.readJson(packageJSONPath);
-            const ver = semver.coerce(packageData.version);
-            if (semver.satisfies(ver, ">= 5.0.0")) {
+    isModernBundler(projectData) {
+        const bundler = this.getBundler();
+        switch (bundler) {
+            case "rspack":
                 return true;
-            }
+            default:
+                const webpackPluginName = this.$projectConfigService.getValue(`webpackPackageName`, constants_1.WEBPACK_PLUGIN_NAME);
+                const packageJSONPath = (0, package_path_helper_1.resolvePackageJSONPath)(webpackPluginName, {
+                    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}".`);
+        }
+        try {
+            if (specificFiles) {
+                if (debugLog) {
+                    console.log("Selective copy - copying specific files:", specificFiles);
+                }
+                this.$fs.createDirectory(destDir);
+                for (const file of specificFiles) {
+                    const srcPath = path.join(distOutput, file);
+                    const destPath = path.join(destDir, file);
+                    if (!this.$fs.exists(srcPath))
+                        continue;
+                    this.$fs.createDirectory(path.dirname(destPath));
+                    this.$fs.copyFile(srcPath, destPath);
+                    if (debugLog) {
+                        console.log(`Copied ${file}`);
+                    }
+                }
+            }
+            else {
+                if (debugLog) {
+                    console.log("Full build: Copying all files.");
+                }
+                if (this.$fs.exists(destDir)) {
+                    this.$fs.deleteDirectory(destDir);
+                }
+                this.$fs.createDirectory(destDir);
+                if (this.$fs.exists(distOutput)) {
+                    this.copyRecursiveSync(distOutput, destDir);
+                }
+                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) {
+        const filesToCopy = [];
+        const bundleFiles = emittedFiles.filter((file) => !file.includes("vendor") &&
+            (file.endsWith(".mjs") ||
+                file.endsWith(".js") ||
+                file.endsWith(".map")));
+        filesToCopy.push(...bundleFiles);
+        const assetFiles = emittedFiles.filter((file) => file.includes("assets/") ||
+            file.includes("static/") ||
+            file.includes("fonts/") ||
+            file.includes("images/"));
+        if (assetFiles.length > 0) {
+            filesToCopy.push(...assetFiles);
+        }
+        return [...new Set(filesToCopy)];
+    }
+    copyRecursiveSync(src, dest) {
+        this.$fs.createDirectory(dest);
+        const entries = this.$fs.readDirectory(src);
+        for (const name of entries) {
+            const srcPath = path.join(src, name);
+            const destPath = path.join(dest, name);
+            const lstats = this.$fs.getLsStats(srcPath);
+            if (lstats.isDirectory()) {
+                this.copyRecursiveSync(srcPath, destPath);
+            }
+            else if (lstats.isFile() || lstats.isSymbolicLink()) {
+                this.$fs.createDirectory(path.dirname(destPath));
+                this.$fs.copyFile(srcPath, destPath);
+            }
+        }
+    }
 }
-exports.WebpackCompilerService = WebpackCompilerService;
+exports.BundlerCompilerService = BundlerCompilerService;
 __decorate([
     (0, decorators_1.performanceLog)()
-], WebpackCompilerService.prototype, "startWebpackProcess", null);
-yok_1.injector.register("webpackCompilerService", WebpackCompilerService);
+], 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/extensibility-service.js

@@ -138,7 +138,7 @@ class ExtensibilityService {
                             return {
                                 extensionName,
                                 registeredCommandName: currentCommand,
-                                installationMessage: `The command ${beautifiedCommandName} is registered in extension ${extensionName}. You can install it by executing 'tns extension install ${extensionName}'`,
+                                installationMessage: `The command ${beautifiedCommandName} is registered in extension ${extensionName}. You can install it by executing 'ns extension install ${extensionName}'`,
                             };
                         }
                         copyOfFullArgs.splice(-1, 1);

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) {
@@ -15,12 +15,23 @@ class SPMService {
         const spmPackages = this.$projectConfigService.getValue(`${platform}.SPMPackages`, []);
         return spmPackages;
     }
+    mergePluginSPMPackages(appPackages, pluginPackages) {
+        const appPackageNames = new Set(appPackages.map(pkg => pkg.name));
+        for (const pluginPkg of pluginPackages) {
+            if (appPackageNames.has(pluginPkg.name)) {
+                this.$logger.trace(`SPM: app package overrides plugin package: ${pluginPkg.name}`);
+            }
+            else {
+                appPackages.push(pluginPkg);
+            }
+        }
+    }
     async applySPMPackages(platformData, projectData, pluginSpmPackages) {
         var _a;
         try {
             const spmPackages = this.getSPMPackages(projectData, platformData.platformNameLowerCase);
             if (pluginSpmPackages === null || pluginSpmPackages === void 0 ? void 0 : pluginSpmPackages.length) {
-                spmPackages.push(...pluginSpmPackages);
+                this.mergePluginSPMPackages(spmPackages, pluginSpmPackages);
             }
             if (!spmPackages.length) {
                 this.$logger.trace("SPM: no SPM packages to apply.");