@nativescript/vite 0.0.1

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

@@ -0,0 +1,17 @@
+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;
+    buildStart(): void;
+    writeBundle(options: any, bundle: any): void;
+};

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

@@ -0,0 +1,128 @@
+import path from "path";
+// 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",
+        buildStart() {
+            if (targetMode === "development") {
+                console.log("🔥 Vite: Build started");
+            }
+        },
+        writeBundle(options, bundle) {
+            if (targetMode === "development") {
+                const buildType = isInitialBuild ? "initial" : "incremental";
+                console.log(`🔥 NativeScript: ${buildType} build completed`);
+                // Get all emitted files from the bundle
+                const emittedFiles = Object.keys(bundle);
+                // Determine what changed
+                const changedFilesList = Array.from(changedFilesTracker);
+                // Determine if this should be an HMR update:
+                // - Not the initial build
+                // - Has specific changed files
+                // - Changes are HMR-compatible (HTML templates, CSS, some TS changes)
+                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);
+                }
+                // For TypeScript changes, this will be a full rebuild (expected)
+                // For CSS changes, this could potentially be optimized (future enhancement)
+                const hasTypeScriptChanges = changedFilesList.some((f) => f.endsWith(".ts"));
+                if (hasTypeScriptChanges) {
+                    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`);
+                // Send IPC message to CLI
+                if (process.send) {
+                    const message = {
+                        emittedFiles: emittedFiles,
+                        chunkFiles: emittedFiles.filter((f) => f.includes("chunk") || f.includes("vendor")),
+                        hash: Date.now().toString(),
+                        isHMR: isHMR && !isInitialBuild, // Mark as HMR for incremental builds
+                        changedFiles: changedFilesList,
+                        buildType: 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);
+                }
+                // Reset trackers AFTER we've used them
+                if (isInitialBuild) {
+                    isInitialBuild = false;
+                    console.log("🔥 Initial build complete - subsequent changes will trigger fast rebuilds");
+                }
+                // Clear the tracker for the next build cycle
+                changedFilesTracker.clear();
+            }
+        },
+    };
+}

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

@@ -0,0 +1,4 @@
+export declare function packagePlatformAliases(tsConfigData: any, platform: string, skipCommonjsPackages?: 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, skipCommonjsPackages, 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) || skipCommonjsPackages?.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[];
+};

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

@@ -0,0 +1,241 @@
+import fs from "fs";
+import path from "path";
+import { getProjectFilePath, getProjectRootPath } from "./project.js";
+let tsConfigPath;
+const projectRoot = getProjectRootPath();
+// Read TypeScript path mappings
+function getTsConfigPaths(debugViteLogs = false) {
+    try {
+        if (debugViteLogs)
+            console.log("📁 Parsing tsconfig at:", tsConfigPath);
+        // The configDir should be the directory of the starting tsconfig file
+        const startingConfigDir = path.dirname(tsConfigPath);
+        // Recursive function to resolve tsconfig extends chain
+        function resolveTsConfigChain(configPath, visitedPaths = new Set()) {
+            // Prevent infinite loops
+            if (visitedPaths.has(configPath)) {
+                if (debugViteLogs)
+                    console.log("📁 Warning: Circular tsconfig extends detected, skipping:", configPath);
+                return { paths: {}, baseUrl: "." };
+            }
+            visitedPaths.add(configPath);
+            const tsConfigContent = fs.readFileSync(configPath, "utf8");
+            // Parse JSON (handle JSONC)
+            let tsConfig;
+            try {
+                tsConfig = JSON.parse(tsConfigContent);
+            }
+            catch (parseError) {
+                // Clean up JSONC
+                if (debugViteLogs)
+                    console.log("📁 Cleaning JSONC for:", configPath);
+                let cleanContent = tsConfigContent
+                    .replace(/\/\/.*$/gm, "")
+                    .replace(/\/\*[\s\S]*?\*\//g, "")
+                    .replace(/,(\s*[}\]])/g, "$1");
+                tsConfig = JSON.parse(cleanContent);
+            }
+            // Start with current config's options
+            let currentPaths = { ...(tsConfig.compilerOptions?.paths || {}) };
+            let mergedBaseUrl = tsConfig.compilerOptions?.baseUrl || ".";
+            const currentConfigDir = path.dirname(configPath);
+            // Handle path resolution for this config file
+            if (currentPaths) {
+                const resolvedPaths = {};
+                for (const [key, values] of Object.entries(currentPaths)) {
+                    if (Array.isArray(values)) {
+                        resolvedPaths[key] = values.map((value) => {
+                            // Handle ${configDir} substitution - use the STARTING config directory
+                            if (value.includes("${configDir}")) {
+                                return value.replace(/\$\{configDir\}/g, startingConfigDir);
+                            }
+                            // For other paths, resolve relative to THIS config file's directory
+                            if (!path.isAbsolute(value)) {
+                                return path.resolve(currentConfigDir, value);
+                            }
+                            return value;
+                        });
+                    }
+                    else {
+                        resolvedPaths[key] = values;
+                    }
+                }
+                currentPaths = resolvedPaths;
+            }
+            // If this config extends another, resolve it first
+            if (tsConfig.extends) {
+                const baseConfigPath = path.resolve(path.dirname(configPath), tsConfig.extends);
+                if (debugViteLogs)
+                    console.log("📁 Following extends to:", baseConfigPath);
+                if (fs.existsSync(baseConfigPath)) {
+                    try {
+                        const baseResult = resolveTsConfigChain(baseConfigPath, visitedPaths);
+                        // Base config comes first, then override with current
+                        const mergedPaths = { ...baseResult.paths, ...currentPaths };
+                        // Use current baseUrl if specified, otherwise inherit from base
+                        if (!tsConfig.compilerOptions?.baseUrl) {
+                            mergedBaseUrl = baseResult.baseUrl;
+                        }
+                        return { paths: mergedPaths, baseUrl: mergedBaseUrl };
+                    }
+                    catch (e) {
+                        if (debugViteLogs)
+                            console.log("📁 Warning: Could not load extended config:", baseConfigPath, e.message);
+                    }
+                }
+                else {
+                    if (debugViteLogs)
+                        console.log("📁 Warning: Extended config not found:", baseConfigPath);
+                }
+            }
+            return { paths: currentPaths, baseUrl: mergedBaseUrl };
+        }
+        const result = resolveTsConfigChain(tsConfigPath);
+        if (debugViteLogs) {
+            console.log("📁 Found paths in tsconfig:", Object.keys(result.paths));
+            console.log("📁 Base URL:", result.baseUrl);
+            console.log("📁 Starting configDir:", startingConfigDir);
+            // Show first few resolved paths for debugging
+            Object.entries(result.paths)
+                .slice(0, 3)
+                .forEach(([key, values]) => {
+                console.log(`📁 Path example: ${key} -> ${values[0]}`);
+            });
+        }
+        return result;
+    }
+    catch (e) {
+        console.warn("Failed to parse tsconfig paths:", e.message);
+        return { paths: {}, baseUrl: "." };
+    }
+}
+// Function to create TypeScript aliases with platform support
+function createTsConfigAliases(paths, baseUrl, platform, debugViteLogs) {
+    const aliases = [];
+    // Process patterns in order: wildcards first, then exact matches
+    const sortedPatterns = Object.entries(paths).sort(([a], [b]) => {
+        // Wildcards (with *) come first
+        const aHasWildcard = a.includes("*");
+        const bHasWildcard = b.includes("*");
+        if (aHasWildcard && !bHasWildcard)
+            return -1;
+        if (!aHasWildcard && bHasWildcard)
+            return 1;
+        // Within same type, longer patterns first (more specific)
+        return b.length - a.length;
+    });
+    for (const [pattern, destinations] of sortedPatterns) {
+        if (Array.isArray(destinations) && destinations.length > 0) {
+            if (pattern.includes("*")) {
+                // Handle wildcard patterns (like "@scope/plugins/*")
+                const aliasKey = pattern.replace(/\/\*$/, "");
+                const destination = destinations[0].replace(/\/\*$/, "");
+                // Check if destination is already absolute (resolved by tsconfig chain)
+                const resolvedDestination = path.isAbsolute(destination)
+                    ? destination
+                    : path.resolve(projectRoot, baseUrl, destination);
+                console.log(`📁 Creating wildcard alias: ${aliasKey} -> ${resolvedDestination}`);
+                aliases.push({
+                    find: new RegExp(`^${aliasKey.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?:/(.*))?$`),
+                    replacement: (match, subpath) => {
+                        const fullPath = subpath
+                            ? path.join(resolvedDestination, subpath)
+                            : resolvedDestination;
+                        if (debugViteLogs) {
+                            console.log(`📁 TypeScript wildcard alias: ${match} -> ${fullPath}`);
+                        }
+                        // Check if this resolves to a directory, and if so, try to find index files
+                        if (fs.existsSync(fullPath) &&
+                            fs.statSync(fullPath).isDirectory()) {
+                            // Try platform-specific index files first
+                            const platformIndexPatterns = [
+                                `index.${platform}.ts`,
+                                `index.${platform}.js`,
+                                `index.${platform}.mjs`,
+                            ];
+                            for (const indexFile of platformIndexPatterns) {
+                                const indexPath = path.join(fullPath, indexFile);
+                                if (fs.existsSync(indexPath)) {
+                                    if (debugViteLogs) {
+                                        console.log(`📁 Found platform-specific directory index: ${indexPath}`);
+                                    }
+                                    return indexPath;
+                                }
+                            }
+                            // Try standard index files
+                            const indexPatterns = ["index.ts", "index.js", "index.mjs"];
+                            for (const indexFile of indexPatterns) {
+                                const indexPath = path.join(fullPath, indexFile);
+                                if (fs.existsSync(indexPath)) {
+                                    if (debugViteLogs) {
+                                        console.log(`📁 Found directory index: ${indexPath}`);
+                                    }
+                                    return indexPath;
+                                }
+                            }
+                        }
+                        // If not a directory or no index found, try platform-specific resolution
+                        const extensions = [".ts", ".js", ".mjs"];
+                        for (const ext of extensions) {
+                            const basePath = fullPath + ext;
+                            // Try platform-specific file first
+                            const platformPath = fullPath + `.${platform}` + ext;
+                            if (fs.existsSync(platformPath)) {
+                                if (debugViteLogs) {
+                                    console.log(`📁 Found platform-specific file: ${platformPath}`);
+                                }
+                                return platformPath;
+                            }
+                            // Try base file
+                            if (fs.existsSync(basePath)) {
+                                if (debugViteLogs) {
+                                    console.log(`📁 Found base file: ${basePath}`);
+                                }
+                                return basePath;
+                            }
+                        }
+                        return fullPath;
+                    },
+                });
+            }
+            else {
+                // Handle exact matches (like "@scope/anything/anywhere")
+                // Use regex to ensure exact match only
+                // Check if destination is already absolute (resolved by tsconfig chain)
+                const resolvedDestination = path.isAbsolute(destinations[0])
+                    ? destinations[0]
+                    : path.resolve(projectRoot, baseUrl, destinations[0]);
+                if (debugViteLogs) {
+                    console.log(`📁 Creating exact alias: ${pattern} -> ${resolvedDestination}`);
+                }
+                aliases.push({
+                    find: new RegExp(`^${pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}$`),
+                    replacement: resolvedDestination,
+                });
+            }
+        }
+    }
+    return aliases;
+}
+// Get TypeScript path configuration
+let tsConfigData;
+export const getTsConfigData = (debugViteLogs, platform) => {
+    tsConfigPath = getProjectFilePath("tsconfig.app.json");
+    if (!fs.existsSync(tsConfigPath)) {
+        tsConfigPath = getProjectFilePath("tsconfig.json");
+    }
+    if (!tsConfigData) {
+        tsConfigData = getTsConfigPaths();
+    }
+    if (debugViteLogs) {
+        console.log("📁 Loaded TypeScript path configuration");
+    }
+    const aliases = createTsConfigAliases(tsConfigData.paths, tsConfigData.baseUrl, platform);
+    if (aliases.length > 0 && debugViteLogs) {
+        console.log("📁 Created TypeScript path aliases:", aliases.length);
+    }
+    return {
+        data: tsConfigData,
+        aliases
+    };
+};

package/dist/helpers/utils.d.ts

@@ -0,0 +1,23 @@
+export declare function nsConfigToJson(): Record<string, any>;
+/**
+ * Resolves the NativeScript platform-specific file for a given module ID.
+ * @param id The module ID to resolve.
+ * @param platform The target platform (e.g., "ios", "android").
+ * @returns The resolved file path or undefined if not found.
+ */
+export declare function resolveNativeScriptPlatformFile(id: string, platform: string): string | undefined;
+/**
+ * Utility to get all dependencies from the project package.json.
+ * The result combines dependencies and devDependencies
+ *
+ * @returns string[] dependencies
+ */
+export declare function getAllDependencies(): string[];
+/**
+ * Check if a dependency is present in package.json
+ */
+export declare function hasDependency(packageName: string): boolean;
+/**
+ * Get the version of a dependency from package.json
+ */
+export declare function getDependencyVersion(packageName: string): string | undefined;