@nativescript/vite 0.0.1

package/dist/helpers/utils.js

@@ -0,0 +1,94 @@
+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 } 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) {
+    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 false;
+    }
+}
+/**
+ * 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 };

package/dist/hmr/hmr-bridge.js

@@ -0,0 +1,154 @@
+/**
+ * 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.
+ */
+import { WebSocketServer } from 'ws';
+import WebSocketType from 'ws';
+import { spawn } from 'child_process';
+import { pathToFileURL } from 'node:url';
+import { resolve } from 'node:path';
+const isMain = () => typeof process !== 'undefined' &&
+    !!process.argv?.[1] &&
+    import.meta.url === pathToFileURL(resolve(process.argv[1])).href;
+class SimpleHMRBridge {
+    constructor() {
+        this.connectedClients = new Set();
+    }
+    async start() {
+        console.log('🔥 Starting Simple HMR Bridge...');
+        // Start WebSocket server for NativeScript app
+        this.startWebSocketServer();
+        // Start NativeScript build process
+        this.startNativeScriptBuild();
+        console.log('🔥 HMR Bridge ready!');
+    }
+    startWebSocketServer() {
+        const HMR_WS_PORT = 24678;
+        this.wsServer = new WebSocketServer({ port: HMR_WS_PORT });
+        this.wsServer.on('connection', (ws) => {
+            console.log('🔥 NativeScript client connected to HMR bridge');
+            this.connectedClients.add(ws);
+            // Send connection confirmation
+            ws.send(JSON.stringify({
+                type: 'connected',
+                timestamp: Date.now()
+            }));
+            ws.on('close', () => {
+                console.log('🔥 NativeScript client disconnected');
+                this.connectedClients.delete(ws);
+            });
+            ws.on('message', (message) => {
+                try {
+                    const data = JSON.parse(message.toString());
+                    console.log('🔥 Received from NativeScript:', data);
+                }
+                catch (e) {
+                    console.error('🔥 Invalid message from NativeScript:', e);
+                }
+            });
+        });
+        console.log(`🔥 HMR bridge listening on ws://localhost:${HMR_WS_PORT}`);
+    }
+    startNativeScriptBuild() {
+        console.log('🔥 Starting NativeScript build with HMR notifications...');
+        // Get platform from command line arguments (default to 'ios' if not provided)
+        const platform = process.argv[2] || 'ios';
+        console.log(`🔥 Building for platform: ${platform}`);
+        // Start ns run with specified platform
+        const args = ['debug', platform];
+        this.buildProcess = spawn('ns', args, {
+            cwd: process.cwd(),
+            stdio: ['inherit', 'pipe', 'pipe'],
+            env: {
+                ...process.env,
+                NS_HMR_BRIDGE: 'true' // Signal to our Vite config that HMR bridge is active
+            }
+        });
+        this.buildProcess.stdout.on('data', (data) => {
+            const output = data.toString();
+            process.stdout.write(output);
+            // Listen for build completion messages
+            this.parseBuildOutput(output);
+        });
+        this.buildProcess.stderr.on('data', (data) => {
+            process.stderr.write(data);
+        });
+        this.buildProcess.on('close', (code) => {
+            console.log(`🔥 NativeScript build process exited with code ${code}`);
+        });
+    }
+    parseBuildOutput(output) {
+        // Look for our HMR indicators in the build output
+        const lines = output.split('\n');
+        for (const line of lines) {
+            // Look for our HMR build completion messages
+            if (line.includes('🔥 HMR update - copying only changed files')) {
+                // Extract changed files from the next lines
+                const changedFilesMatch = line.match(/🔥 HMR update - copying only changed files for: (.+)/);
+                if (changedFilesMatch) {
+                    try {
+                        const changedFiles = JSON.parse(changedFilesMatch[1].replace(/'/g, '"'));
+                        this.notifyClients({
+                            type: 'build-complete',
+                            timestamp: Date.now(),
+                            changedFiles,
+                            buildType: 'incremental',
+                            isHMR: true
+                        });
+                    }
+                    catch (e) {
+                        console.log('🔥 Could not parse changed files from:', changedFilesMatch[1]);
+                    }
+                }
+            }
+            else if (line.includes('🔥 Full build - copying all files')) {
+                this.notifyClients({
+                    type: 'build-complete',
+                    timestamp: Date.now(),
+                    buildType: 'full',
+                    isHMR: false
+                });
+            }
+            else if (line.includes('Vite build completed!')) {
+                // Build is done, notify clients
+                console.log('🔥 Build completed, notifying clients...');
+            }
+        }
+    }
+    notifyClients(update) {
+        const message = JSON.stringify(update);
+        let sentCount = 0;
+        this.connectedClients.forEach((client) => {
+            if (client.readyState === WebSocketType.OPEN) {
+                client.send(message);
+                sentCount++;
+            }
+        });
+        if (sentCount > 0) {
+            console.log(`🔥 Notified ${sentCount} clients of update:`, update.type);
+        }
+    }
+    async stop() {
+        console.log('🔥 Stopping HMR bridge...');
+        if (this.buildProcess) {
+            this.buildProcess.kill('SIGTERM');
+        }
+        if (this.wsServer) {
+            this.wsServer.close();
+        }
+    }
+}
+// Export for use in startup script
+export { SimpleHMRBridge };
+// Auto-start if run directly
+if (isMain()) {
+    const bridge = new SimpleHMRBridge();
+    bridge.start().catch(console.error);
+    // Handle graceful shutdown
+    process.on('SIGINT', () => {
+        console.log('\n🔥 Shutting down HMR bridge...');
+        bridge.stop().then(() => process.exit(0));
+    });
+}

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

@@ -0,0 +1,5 @@
+/**
+ * Simple NativeScript HMR Client for Vite
+ * Based on @nativescript/webpack loaders but simplified for Vite
+ */
+export {};

package/dist/hmr/hmr-client.js

@@ -0,0 +1,93 @@
+/**
+ * Simple NativeScript HMR Client for Vite
+ * Based on @nativescript/webpack loaders but simplified for Vite
+ */
+// Import WebSocket polyfill directly
+import { WebSocket as NativeScriptWebSocket } from '@valor/nativescript-websockets/websocket';
+// Ensure WebSocket is available globally for other code
+if (typeof global !== 'undefined') {
+    global.WebSocket = NativeScriptWebSocket;
+}
+// Make WebSocket available in current scope
+const WebSocket = NativeScriptWebSocket;
+// import { Application } from "@nativescript/core";
+let hmrBootEmittedSymbol = Symbol.for("HMRBootEmitted");
+let originalLiveSyncSymbol = Symbol.for("OriginalLiveSync");
+let hmrRuntimeLastLiveSyncSymbol = Symbol.for("HMRRuntimeLastLiveSync");
+if (global.__onLiveSync !== global[hmrRuntimeLastLiveSyncSymbol]) {
+    // we store the original liveSync here in case this code runs again
+    // which happens when you module.hot.accept() the main file
+    global[originalLiveSyncSymbol] = global.__onLiveSync;
+}
+global[hmrRuntimeLastLiveSyncSymbol] = async function () {
+    console.log(`calling global[hmrRuntimeLastLiveSyncSymbol]`);
+    await global[originalLiveSyncSymbol]();
+};
+global.__onLiveSync = global[hmrRuntimeLastLiveSyncSymbol];
+if (!global[hmrBootEmittedSymbol]) {
+    global[hmrBootEmittedSymbol] = true;
+}
+/**
+ * Note: allow vite to inject each flavor client handling
+ * Start Manual Flavor Testing
+ */
+const flavor = "angular";
+import { handleAngularHmrUpdate } from "./hmr-angular.js";
+/**
+ * End Manual Flavor Testing
+ */
+class SimpleNativeScriptHMRClient {
+    constructor() {
+        this.ws = null;
+        console.log("🔥 Simple HMR Client starting...");
+        console.log("🔥 WebSocket available:", typeof WebSocket !== 'undefined');
+        console.log("🔥 global.WebSocket available:", typeof global !== 'undefined' && typeof global.WebSocket !== 'undefined');
+        this.connect();
+    }
+    connect() {
+        try {
+            // Check if WebSocket is available
+            if (typeof WebSocket === 'undefined') {
+                console.error("🔥 WebSocket is not available - HMR disabled");
+                return;
+            }
+            this.ws = new WebSocket("ws://localhost:24678");
+            this.ws.onopen = () => {
+                console.log("🔥 HMR connected");
+            };
+            this.ws.onmessage = (event) => {
+                try {
+                    const update = JSON.parse(event.data);
+                    this.handleUpdate(update);
+                }
+                catch (error) {
+                    console.error("🔥 HMR message error:", error);
+                }
+            };
+        }
+        catch (error) {
+            console.error("🔥 HMR connection failed:", error);
+        }
+    }
+    handleUpdate(update) {
+        console.log("🔥 HMR update received:", update.type);
+        if (update.type === "build-complete" && update.isHMR) {
+            // skip very first one since it's initial build
+            console.log("🔥 Applying HMR update for:", update.changedFiles);
+            switch (flavor) {
+                case "angular":
+                    // Handle Angular specific HMR updates
+                    handleAngularHmrUpdate();
+                    break;
+            }
+        }
+    }
+}
+// Initialize on app launch
+let hmrClient;
+if (!hmrClient) {
+    console.log("🔥 Initializing Simple NativeScript HMR Client");
+    // Application.on(Application.launchEvent, () => {
+    hmrClient = new SimpleNativeScriptHMRClient();
+    // });
+}

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

@@ -0,0 +1,20 @@
+/**
+ * NativeScript True HMR Implementation
+ *
+ * This creates a bridge between Vite's dev server HMR and NativeScript runtime
+ * to enable true hot module replacement without losing application state.
+ */
+declare class NativeScriptHMRServer {
+    private viteServer;
+    private wsServer;
+    private buildProcess;
+    private connectedClients;
+    start(): Promise<void>;
+    private startViteDevServer;
+    private startHMRBridge;
+    private handleViteHMRMessage;
+    private broadcastToClients;
+    private startBuildProcess;
+    stop(): Promise<void>;
+}
+export { NativeScriptHMRServer };