@nativescript/vite 0.0.1-alpha.0

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,29 @@
+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;
+/**
+ * Utility to get the path (usually nested in node_modules) of a dependency.
+ *
+ * @param dependencyName
+ */
+export declare function getDependencyPath(dependencyName: string): string | null;
+/**
+ * Get the version of a dependency from package.json
+ */
+export declare function getDependencyVersion(packageName: string): string | undefined;

package/dist/helpers/utils.js

@@ -0,0 +1,101 @@
+import path from "path";
+import fs from "fs";
+import { transformSync } from "esbuild";
+import { satisfies } from "semver";
+import { createRequire } from 'node:module';
+const require = createRequire(import.meta.url);
+import { getPackageJson, getProjectFilePath, getProjectRootPath } from "./project.js";
+// get the name from the package for the output
+const packageJson = getPackageJson();
+export function nsConfigToJson() {
+    let configObject;
+    ;
+    const tsPath = getProjectFilePath("nativescript.config.ts");
+    const tsCode = fs.readFileSync(tsPath, "utf-8");
+    // a) Transpile your TS config to CommonJS so we can require() it
+    const { code: cjsCode } = transformSync(tsCode, {
+        loader: "ts",
+        format: "cjs",
+        target: "esnext",
+    });
+    // b) Evaluate it in a VM-style sandbox to pull out the default export
+    const module = { exports: {} };
+    const requireFunc = (id) => require(id);
+    new Function("exports", "require", "module", "__filename", "__dirname", cjsCode)(module.exports, requireFunc, module, tsPath, path.dirname(tsPath));
+    configObject = module.exports.default ?? module.exports;
+    // ensure the config has a name
+    configObject.name = packageJson.name;
+    // ensure the main entry is set to "bundle"
+    configObject.main = "bundle";
+    return configObject;
+}
+/**
+ * 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 function resolveNativeScriptPlatformFile(id, platform) {
+    const ext = path.extname(id);
+    const base = id.slice(0, -ext.length);
+    let platformFile = `${base}.${platform}${ext}`;
+    if (fs.existsSync(platformFile)) {
+        return platformFile;
+    }
+    // core uses indices for many barrels
+    platformFile = `${base}/index.${platform}${ext}`;
+    if (fs.existsSync(platformFile)) {
+        return platformFile;
+    }
+    // fallback to non-platform file
+    return fs.existsSync(id) ? id : undefined;
+}
+/**
+ * Utility to get all dependencies from the project package.json.
+ * The result combines dependencies and devDependencies
+ *
+ * @returns string[] dependencies
+ */
+export function getAllDependencies() {
+    return [
+        ...Object.keys(packageJson.dependencies ?? {}),
+        ...Object.keys(packageJson.devDependencies ?? {}),
+    ];
+}
+/**
+ * Check if a dependency is present in package.json
+ */
+export function hasDependency(packageName) {
+    return getAllDependencies().includes(packageName);
+}
+/**
+ * Utility to get the path (usually nested in node_modules) of a dependency.
+ *
+ * @param dependencyName
+ */
+export function getDependencyPath(dependencyName) {
+    try {
+        const resolvedPath = require.resolve(`${dependencyName}/package.json`, {
+            paths: [getProjectRootPath()],
+        });
+        return path.dirname(resolvedPath);
+    }
+    catch (err) {
+        return null;
+    }
+}
+/**
+ * Get the version of a dependency from package.json
+ */
+export function getDependencyVersion(packageName) {
+    try {
+        const packageJsonPath = path.resolve(process.cwd(), "package.json");
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+        return (packageJson.dependencies?.[packageName] ||
+            packageJson.devDependencies?.[packageName] ||
+            packageJson.peerDependencies?.[packageName]);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/helpers/workers.d.ts

@@ -0,0 +1,20 @@
+export declare function getWorkerPlugins(platform: string): ({
+    name: string;
+    resolveId(id: any): string;
+    load(id: any): string;
+    transform?: undefined;
+} | {
+    name: string;
+    resolveId(id: any, importer: any): string;
+    load?: undefined;
+    transform?: undefined;
+} | {
+    name: string;
+    transform(code: any, id: any): any;
+    resolveId?: undefined;
+    load?: undefined;
+})[];
+export declare function workerUrlPlugin(): {
+    name: string;
+    generateBundle(options: any, bundle: any): void;
+};

package/dist/helpers/workers.js

@@ -0,0 +1,86 @@
+import path from "path";
+import { nsConfigToJson, resolveNativeScriptPlatformFile } from "./utils.js";
+export function getWorkerPlugins(platform) {
+    return [
+        // Handle ~/package.json virtual module for workers
+        {
+            name: "worker-virtual-package-json",
+            resolveId(id) {
+                if (id === "~/package.json") {
+                    return "\0worker:nsconfig-json"; // Use a completely different virtual ID that doesn't look like JSON
+                }
+                return null;
+            },
+            load(id) {
+                if (id === "\0worker:nsconfig-json") {
+                    const configObject = nsConfigToJson();
+                    // Return the NativeScript config as a JavaScript module
+                    return `export default ${JSON.stringify(configObject, null, 2)};`;
+                }
+                return null;
+            },
+        },
+        // Resolve NativeScript platform-specific files for workers
+        {
+            name: "nativescript-platform-resolver-worker",
+            resolveId(id, importer) {
+                // Handle relative imports from node_modules (not just @nativescript/core)
+                if (importer) {
+                    const resolvedPath = path.resolve(path.dirname(importer), id);
+                    // Try different extensions with platform-specific resolution
+                    const extensions = [".js", ".mjs", ".ts", ".vue"];
+                    for (const ext of extensions) {
+                        const testPath = resolvedPath + ext;
+                        // Use the existing NativeScript platform file resolver
+                        const platformResolvedFile = resolveNativeScriptPlatformFile(testPath, platform);
+                        if (platformResolvedFile) {
+                            return platformResolvedFile;
+                        }
+                    }
+                    return null;
+                }
+                return null;
+            },
+        },
+        // Handle import.meta expressions in workers
+        {
+            name: "worker-import-meta-handler",
+            transform(code, id) {
+                // Replace import.meta.dirname with a static value for workers
+                if (code.includes("import.meta.dirname")) {
+                    code = code.replace(/import\.meta\.dirname/g, '""');
+                }
+                // Replace import.meta.url with a static value for workers
+                if (code.includes("import.meta.url")) {
+                    code = code.replace(/import\.meta\.url/g, '"file:///app/"');
+                }
+                return code;
+            },
+        },
+    ];
+}
+export function workerUrlPlugin() {
+    return {
+        name: "nativescript-worker-url-transform",
+        generateBundle(options, bundle) {
+            // Transform the main bundle to use NativeScript worker paths
+            for (const [fileName, chunk] of Object.entries(bundle)) {
+                if (chunk.type === "chunk" && !fileName.includes(".worker")) {
+                    // Transform Vite's worker URL pattern to NativeScript's expected format
+                    // From: new Worker(new URL(/* @vite-ignore */ "/assets/sample.worker-C6wW8q2-.js", import.meta.url))
+                    // To: new Worker('~/' + 'assets/sample.worker-C6wW8q2-.js')
+                    const workerUrlRegex = /new\s+Worker\s*\(\s*new\s+URL\s*\(\s*(?:\/\*[^*]*\*\/\s*)?["']([^"']+)["']\s*,\s*import\.meta\.url\s*\)\s*\)/g;
+                    if (workerUrlRegex.test(chunk.code)) {
+                        chunk.code = chunk.code.replace(workerUrlRegex, (match, assetPath) => {
+                            // Use the full asset path including assets/ folder
+                            const fullPath = assetPath.startsWith("/")
+                                ? assetPath.slice(1)
+                                : assetPath;
+                            return `new Worker('~/' + '${fullPath}')`;
+                        });
+                    }
+                }
+            }
+        },
+    };
+}

package/dist/hmr/hmr-angular.d.ts

@@ -0,0 +1 @@
+export declare function handleAngularHmrUpdate(): void;

package/dist/hmr/hmr-angular.js

@@ -0,0 +1,34 @@
+import { isDevMode, ɵresetCompiledComponents,
+// @ts-ignore
+ } from "@angular/core";
+export function handleAngularHmrUpdate() {
+    // Reset JIT compiled components cache
+    ɵresetCompiledComponents();
+    try {
+        console.log(`typeof global["__cleanup_ng_hot__"]`, typeof global["__cleanup_ng_hot__"]);
+        if (global["__cleanup_ng_hot__"])
+            global["__cleanup_ng_hot__"]();
+        global["__reboot_ng_modules__"]();
+        console.log('angular called __reboot_ng_modules__!');
+        // need to call some kind of apply here?
+        // Webpack would call in this order with angular-hot-loader/hmr-accept:
+        /**
+           *   angular hot dispose called!
+            hot dispose called here?!
+            __cleanup_ng_hot__ called!
+            angular hot accept about to be called!
+            Angular is running in development mode.
+            [HMR][bd598ae5b97083449f33] success | Successfully applied update.
+            calling global.__onLiveSync!
+           */
+        global.__onLiveSync();
+    }
+    catch (e) {
+        console.error("[NG HMR] Error disposing previous module");
+        console.error(e, e?.stack);
+        // HMR breaks when rejecting the main module dispose, so we manually trigger an HMR restart
+        // const hash = __webpack_require__.h();
+        // console.log(`[HMR][${hash}] failure | Error disposing previous module`);
+        // throw e;
+    }
+}

package/dist/hmr/hmr-bridge.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Simple HMR Notification Bridge
+ *
+ * This creates a lightweight WebSocket server that the NativeScript CLI
+ * can notify when builds complete, and forwards those to the app.
+ */
+declare class SimpleHMRBridge {
+    private wsServer;
+    private connectedClients;
+    private buildProcess;
+    start(): Promise<void>;
+    private startWebSocketServer;
+    private startNativeScriptBuild;
+    private parseBuildOutput;
+    private notifyClients;
+    stop(): Promise<void>;
+}
+export { SimpleHMRBridge };