@nativescript/vite 0.0.1-alpha.0

package/dist/helpers/nativescript-package-resolver.js

@@ -0,0 +1,139 @@
+import path from "path";
+import fs from "fs";
+import { getProjectRootPath } from "./project.js";
+import { findPackageInNodeModules } from "./module-resolution.js";
+const projectRoot = getProjectRootPath();
+// Cache for package resolution results
+const packageCache = new Map();
+export function nativescriptPackageResolver(platform) {
+    return {
+        name: "nativescript-package-resolver",
+        enforce: "pre", // Force this plugin to run before all others
+        resolveId(id, importer) {
+            // Only handle direct package imports (not relative paths)
+            if (id.startsWith(".") || id.startsWith("/") || id.includes(":")) {
+                return null;
+            }
+            // Extract package name properly
+            let packageName;
+            if (id.startsWith("@")) {
+                // Scoped package: @scope/package or @scope/package/subpath
+                const parts = id.split("/");
+                if (parts.length >= 2) {
+                    packageName = parts[0] + "/" + parts[1]; // @scope/package
+                    // Only handle root package imports, not subpaths
+                    if (parts.length > 2) {
+                        return null; // This is a subpath import like @scope/package/file
+                    }
+                }
+                else {
+                    return null; // Invalid scoped package
+                }
+            }
+            else {
+                // Regular package: package or package/subpath
+                const parts = id.split("/");
+                packageName = parts[0];
+                // Only handle root package imports, not subpaths
+                if (parts.length > 1) {
+                    return null; // This is a subpath import like package/file
+                }
+            }
+            // Check cache first
+            if (packageCache.has(packageName)) {
+                const cachedResult = packageCache.get(packageName);
+                if (cachedResult === null) {
+                    return null; // Previously determined to not need platform resolution
+                }
+                return cachedResult;
+            }
+            const packagePath = findPackageInNodeModules(packageName, projectRoot);
+            if (packagePath) {
+                const packageJsonPath = path.join(packagePath, "package.json");
+                if (fs.existsSync(packageJsonPath)) {
+                    try {
+                        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+                        const mainField = packageJson.main;
+                        if (mainField) {
+                            const mainFilePath = path.join(packagePath, mainField);
+                            // Case 1: Main field has no extension - try to add extensions
+                            if (!mainField.includes(".")) {
+                                // Try platform-specific file first
+                                const platformFile = path.join(packagePath, `${mainField}.${platform}.js`);
+                                if (fs.existsSync(platformFile)) {
+                                    const result = {
+                                        id: platformFile,
+                                        resolvedBy: "nativescript-package-resolver",
+                                    };
+                                    packageCache.set(packageName, result);
+                                    //   console.log(
+                                    //     `🔧 Package resolver: ${packageName} -> ${mainField}.${platform}.js (extensionless)`,
+                                    //   );
+                                    return result;
+                                }
+                                // Fallback to .js
+                                const jsFile = path.join(packagePath, `${mainField}.js`);
+                                if (fs.existsSync(jsFile)) {
+                                    const result = {
+                                        id: jsFile,
+                                        resolvedBy: "nativescript-package-resolver",
+                                    };
+                                    packageCache.set(packageName, result);
+                                    // console.log(
+                                    //   `🔧 Package resolver: ${packageName} -> ${mainField}.js (extensionless)`,
+                                    // );
+                                    return result;
+                                }
+                            }
+                            // Case 2: Main field has extension but file doesn't exist - look for platform variants
+                            else if (!fs.existsSync(mainFilePath)) {
+                                // Extract base name and extension
+                                const ext = path.extname(mainField);
+                                const baseName = mainField.slice(0, -ext.length);
+                                // Try platform-specific file first
+                                const platformFile = path.join(packagePath, `${baseName}.${platform}${ext}`);
+                                if (fs.existsSync(platformFile)) {
+                                    const result = {
+                                        id: platformFile,
+                                        resolvedBy: "nativescript-package-resolver",
+                                    };
+                                    packageCache.set(packageName, result);
+                                    //   console.log(
+                                    //     `🔧 Package resolver: ${packageName} -> ${baseName}.${platform}${ext} (missing main)`,
+                                    //   );
+                                    return result;
+                                }
+                                // Cache as null - no platform variant found
+                                packageCache.set(packageName, null);
+                                return null;
+                            }
+                            else {
+                                // Main file exists - let normal resolution handle it
+                                packageCache.set(packageName, null);
+                                return null;
+                            }
+                        }
+                    }
+                    catch (e) {
+                        // Cache as null on error
+                        packageCache.set(packageName, null);
+                        return null;
+                    }
+                }
+                else {
+                    // No package.json found
+                    packageCache.set(packageName, null);
+                    return null;
+                }
+            }
+            else {
+                // Package doesn't exist
+                packageCache.set(packageName, null);
+                return null;
+            }
+            // Cache as null and return null
+            packageCache.set(packageName, null);
+            return null;
+        },
+    };
+}

package/dist/helpers/ns-cli-plugins.d.ts

@@ -0,0 +1,19 @@
+export declare function hmrPlugin(targetMode: string): {
+    name: string;
+    buildStart(): void;
+    watchChange(id: any, { event }: {
+        event: any;
+    }): void;
+    handleHotUpdate({ file, server, timestamp }: {
+        file: any;
+        server: any;
+        timestamp: any;
+    }): any[];
+};
+export declare function cliPlugin(targetMode: string, cliFlags: any): {
+    name: string;
+    enforce: "post";
+    configResolved(config: any): void;
+    buildStart(): void;
+    closeBundle(): void;
+};

package/dist/helpers/ns-cli-plugins.js

@@ -0,0 +1,162 @@
+import path from "path";
+import { readdirSync, statSync } from "fs";
+// NativeScript HMR integration - track changes for incremental builds
+// Track changed files globally for HMR
+let changedFilesTracker = new Set();
+let isInitialBuild = true;
+export function hmrPlugin(targetMode) {
+    return {
+        name: "nativescript-hmr",
+        buildStart() {
+            if (targetMode === "development") {
+                console.log("🔥 Vite: Build started");
+                // Don't clear changedFilesTracker here - we need it for writeBundle
+                // We'll clear it in writeBundle after using it
+            }
+        },
+        // Use watchChange hook to track file changes in build mode
+        watchChange(id, { event }) {
+            if (targetMode === "development") {
+                const relativePath = path.relative(process.cwd(), id);
+                // Only track changes in src directory and config files
+                const shouldTrack = relativePath.startsWith("src/");
+                if (!shouldTrack) {
+                    return; // Ignore changes to build outputs, platforms, node_modules, etc.
+                }
+                console.log(`🔥 File ${event}:`, relativePath);
+                // Track the changed file
+                changedFilesTracker.add(relativePath);
+                // Log the type of change for debugging
+                if (id.endsWith(".css") || id.endsWith(".scss")) {
+                    console.log("🔥 CSS file change detected");
+                }
+                else if (id.endsWith(".html")) {
+                    console.log("🔥 HTML template change detected");
+                }
+                else if (id.endsWith(".ts") && !id.endsWith(".d.ts")) {
+                    console.log("🔥 TypeScript file change detected");
+                }
+            }
+        },
+        // Keep handleHotUpdate for completeness, but it won't fire in build mode
+        handleHotUpdate({ file, server, timestamp }) {
+            if (targetMode === "development") {
+                const relativePath = path.relative(process.cwd(), file);
+                // Only handle HMR for src directory and config files
+                const shouldHandle = relativePath.startsWith("src/");
+                if (!shouldHandle) {
+                    return []; // Ignore HMR for build outputs, platforms, node_modules, etc.
+                }
+                console.log("🔥 HMR update detected for:", relativePath);
+                console.log("🔥 Note: This only fires in dev server mode, not build mode");
+                return;
+            }
+        },
+    };
+}
+// NativeScript CLI integration - including IPC communication for HMR
+export function cliPlugin(targetMode, cliFlags) {
+    return {
+        name: "nativescript-cli-integration",
+        // Ensure we run after other plugins (like vite-plugin-static-copy)
+        enforce: "post",
+        // Resolve build outDir so we can read final outputs after all plugins finish
+        configResolved(config) {
+            // no-op, but we keep reference on the closure via getOutDir
+            getOutDir = () => path.resolve(config.root ?? process.cwd(), config.build?.outDir ?? "dist");
+        },
+        buildStart() {
+            if (targetMode === "development") {
+                console.log("🔥 Vite: Build started");
+            }
+        },
+        // Defer CLI notification until after all plugins (including static copy) are done.
+        closeBundle() {
+            if (targetMode !== "development")
+                return;
+            const buildType = isInitialBuild ? "initial" : "incremental";
+            console.log(`🔥 NativeScript: ${buildType} build completed`);
+            // After static copy has finished, read actual dist contents
+            const distDir = getOutDir();
+            const emittedFiles = listFilesFlat(distDir);
+            // Determine what changed
+            const changedFilesList = Array.from(changedFilesTracker);
+            const hasHTMLChanges = changedFilesList.some((f) => f.endsWith(".html"));
+            const hasCSSChanges = changedFilesList.some((f) => f.endsWith(".css") || f.endsWith(".scss"));
+            const hasComponentChanges = changedFilesList.some((f) => f.includes(".component."));
+            const canUseHMR = !isInitialBuild &&
+                changedFilesList.length > 0 &&
+                (hasHTMLChanges || hasCSSChanges || hasComponentChanges);
+            const isHMR = canUseHMR && cliFlags.hmr;
+            if (changedFilesList.length > 0) {
+                console.log("🔥 Changed files triggered rebuild:", changedFilesList);
+                console.log("🔥 Can use HMR:", canUseHMR);
+            }
+            if (changedFilesList.some((f) => f.endsWith(".ts"))) {
+                console.log("🔥 TypeScript changes detected - full rebuild required");
+            }
+            if (hasCSSChanges) {
+                console.log("🔥 CSS changes detected - could be optimized for HMR in future");
+            }
+            if (hasHTMLChanges) {
+                console.log("🔥 HTML template changes detected - using HMR");
+            }
+            console.log(`🔥 Emitted ${emittedFiles.length} files in ${buildType} build`);
+            if (process.send) {
+                const message = {
+                    emittedFiles,
+                    chunkFiles: emittedFiles.filter((f) => f.includes("chunk") || f.includes("vendor")),
+                    hash: Date.now().toString(),
+                    isHMR: isHMR && !isInitialBuild,
+                    changedFiles: changedFilesList,
+                    buildType,
+                    timestamp: Date.now(),
+                };
+                console.log(`🔥 Sending ${buildType} build notification to CLI (isHMR: ${message.isHMR})`);
+                if (changedFilesList.length > 0) {
+                    console.log("🔥 IPC includes changed files:", changedFilesList);
+                }
+                process.send(message);
+            }
+            if (isInitialBuild) {
+                isInitialBuild = false;
+                console.log("🔥 Initial build complete - subsequent changes will trigger fast rebuilds");
+            }
+            changedFilesTracker.clear();
+        },
+    };
+}
+// Helper to get outDir resolved at runtime
+let getOutDir = () => path.resolve(process.cwd(), "dist");
+// Recursively list files under a directory and return relative paths
+function listFilesFlat(rootDir) {
+    const results = [];
+    function walk(dir, relBase = "") {
+        let entries = [];
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return;
+        }
+        for (const name of entries) {
+            const abs = path.join(dir, name);
+            const rel = path.join(relBase, name);
+            let s;
+            try {
+                s = statSync(abs);
+            }
+            catch {
+                continue;
+            }
+            if (s.isDirectory()) {
+                walk(abs, rel);
+            }
+            else if (s.isFile()) {
+                results.push(rel);
+            }
+        }
+    }
+    walk(rootDir);
+    return results;
+}

package/dist/helpers/package-platform-aliases.d.ts

@@ -0,0 +1,4 @@
+export declare function packagePlatformAliases(tsConfigData: any, platform: string, debugViteLogs?: boolean): {
+    find: RegExp;
+    replacement: (id: any) => any;
+};

package/dist/helpers/package-platform-aliases.js

@@ -0,0 +1,83 @@
+import path from "path";
+import fs from "fs";
+import { findPackageInNodeModules } from "./module-resolution.js";
+import { getProjectRootPath } from "./project.js";
+const projectRoot = getProjectRootPath();
+export function packagePlatformAliases(tsConfigData, platform, debugViteLogs) {
+    // packages used via core transient dependencies and other vite support
+    const commonSkips = [
+        "source-map-js",
+        "html-entities",
+        "fast-xml-parser",
+        "@valor/nativescript-websockets",
+    ];
+    return {
+        find: /^(@[^/]+\/[^@/]+|[^@/]+)$/,
+        replacement: (id) => {
+            // Skip packages that have custom plugins
+            if (commonSkips.includes(id)) {
+                return id; // Let the plugins handle these
+            }
+            // Skip if this ID is already handled by tsconfig paths
+            // Check if this matches any of our tsconfig path aliases
+            if (tsConfigData.paths && tsConfigData.paths[id]) {
+                return id; // Let tsconfig aliases handle this
+            }
+            // Only handle packages that exist in node_modules (real npm packages)
+            const packageName = id;
+            const packagePath = findPackageInNodeModules(packageName, projectRoot);
+            if (packagePath) {
+                const packageJsonPath = path.join(packagePath, "package.json");
+                if (fs.existsSync(packageJsonPath)) {
+                    try {
+                        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+                        const mainField = packageJson.main;
+                        if (mainField) {
+                            const mainFilePath = path.join(packagePath, mainField);
+                            // Case 1: Main field has no extension - try to add extensions
+                            if (!mainField.includes(".")) {
+                                // Try platform-specific file first
+                                const platformFile = path.join(packagePath, `${mainField}.${platform}.js`);
+                                if (fs.existsSync(platformFile)) {
+                                    if (debugViteLogs) {
+                                        console.log(`✅ Alias resolver: ${packageName} -> ${mainField}.${platform}.js (extensionless)`);
+                                    }
+                                    return platformFile;
+                                }
+                                // Fallback to .js
+                                const jsFile = path.join(packagePath, `${mainField}.js`);
+                                if (fs.existsSync(jsFile)) {
+                                    if (debugViteLogs) {
+                                        console.log(`✅ Alias resolver: ${packageName} -> ${mainField}.js (extensionless)`);
+                                    }
+                                    return jsFile;
+                                }
+                            }
+                            // Case 2: Main field has extension but file doesn't exist - look for platform variants
+                            else if (!fs.existsSync(mainFilePath)) {
+                                // Extract base name and extension
+                                const ext = path.extname(mainField);
+                                const baseName = mainField.slice(0, -ext.length);
+                                // Try platform-specific file first
+                                const platformFile = path.join(packagePath, `${baseName}.${platform}${ext}`);
+                                if (fs.existsSync(platformFile)) {
+                                    if (debugViteLogs) {
+                                        console.log(`✅ Alias resolver: ${packageName} -> ${baseName}.${platform}${ext} (missing main)`);
+                                    }
+                                    return platformFile;
+                                }
+                                // If main file exists, let normal resolution handle it
+                                // If it doesn't exist and no platform variant found, let it fail naturally
+                            }
+                        }
+                    }
+                    catch (e) {
+                        // Ignore parse errors and fall through
+                    }
+                }
+            }
+            // Return original if no resolution needed
+            return id;
+        },
+    };
+}

package/dist/helpers/project.d.ts

@@ -0,0 +1,23 @@
+export declare function getProjectRootPath(): string;
+export declare const __dirname: string;
+interface IPackageJson {
+    name?: string;
+    main?: string;
+    dependencies?: {
+        [name: string]: string;
+    };
+    devDependencies?: {
+        [name: string]: string;
+    };
+}
+/**
+ * Utility function to get the contents of the project package.json
+ */
+export declare function getPackageJson(): IPackageJson;
+/**
+ * Utility to get project files relative to the project root.
+ * @param filePath path to get
+ */
+export declare function getProjectFilePath(filePath: string): string;
+export declare function getProjectTSConfigPath(): string | undefined;
+export {};

package/dist/helpers/project.js

@@ -0,0 +1,28 @@
+import { existsSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+export function getProjectRootPath() {
+    return process.cwd();
+}
+// Get current directory for ES modules (equivalent to __dirname)
+export const __dirname = dirname(new URL(import.meta.url).pathname);
+/**
+ * Utility function to get the contents of the project package.json
+ */
+export function getPackageJson() {
+    return require(getProjectFilePath('package.json'));
+}
+/**
+ * Utility to get project files relative to the project root.
+ * @param filePath path to get
+ */
+export function getProjectFilePath(filePath) {
+    return resolve(getProjectRootPath(), filePath);
+}
+export function getProjectTSConfigPath() {
+    return [
+        getProjectFilePath('tsconfig.app.json'),
+        getProjectFilePath('tsconfig.json'),
+    ].find((path) => existsSync(path));
+}

package/dist/helpers/resolver.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from "vite";
+export default function NativeScriptPlugin(options: {
+    platform: "ios" | "android" | "visionos";
+}): Plugin;

package/dist/helpers/resolver.js

@@ -0,0 +1,31 @@
+import path from "path";
+import { resolveNativeScriptPlatformFile } from "./utils.js";
+export default function NativeScriptPlugin(options) {
+    return {
+        name: "vite:nativescript",
+        resolveId(source, importer) {
+            const platform = options.platform;
+            if (!platform || !importer || source.startsWith(".") === false) {
+                return null;
+            }
+            const resolved = path.resolve(path.dirname(importer), source);
+            const extVariants = [".ts", ".js", ".vue"];
+            for (const ext of extVariants) {
+                const file = resolveNativeScriptPlatformFile(resolved + ext, platform);
+                if (file) {
+                    return file;
+                }
+            }
+            return null;
+        },
+        transform(code, id) {
+            if (id.endsWith(".xml") || id.endsWith(".vue")) {
+                // Example: simple pass-through or custom transform for NativeScript view files
+                return {
+                    code,
+                    map: null,
+                };
+            }
+        },
+    };
+}

package/dist/helpers/ts-config-paths.d.ts

@@ -0,0 +1,4 @@
+export declare const getTsConfigData: (debugViteLogs: boolean, platform: string) => {
+    data: any;
+    aliases: any[];
+};