@nativescript/vite 0.0.1-alpha.0

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 };

package/dist/hmr/hmr-server.js

@@ -0,0 +1,179 @@
+/**
+ * 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.
+ */
+import { createServer } from 'vite';
+import { spawn } from 'child_process';
+import { WebSocketServer, WebSocket } from 'ws';
+import path from 'path';
+import fs from 'fs';
+import { getProjectFilePath } from '../helpers/project.js';
+const HMR_WS_PORT = 24678; // Different from Vite's default
+const VITE_DEV_PORT = 5173;
+class NativeScriptHMRServer {
+    constructor() {
+        this.connectedClients = new Set();
+    }
+    async start() {
+        console.log('🔥 Starting NativeScript True HMR...');
+        // 1. Start Vite dev server for true HMR
+        await this.startViteDevServer();
+        // 2. Start WebSocket bridge for NativeScript
+        await this.startHMRBridge();
+        // 3. Start build process for NativeScript integration
+        await this.startBuildProcess();
+        console.log('🔥 True HMR ready! Connect your NativeScript app.');
+    }
+    async startViteDevServer() {
+        console.log('🔥 Starting Vite dev server...');
+        this.viteServer = await createServer({
+            configFile: getProjectFilePath('vite.config.ts'),
+            server: {
+                port: VITE_DEV_PORT,
+                hmr: {
+                    port: VITE_DEV_PORT + 1, // Vite's internal HMR port
+                }
+            },
+            mode: 'ios' // or get from args
+        });
+        await this.viteServer.listen();
+        console.log(`🔥 Vite dev server running on http://localhost:${VITE_DEV_PORT}`);
+        // Hook into Vite's HMR system
+        this.viteServer.ws.on('send', (data) => {
+            this.handleViteHMRMessage(data);
+        });
+    }
+    async startHMRBridge() {
+        console.log('🔥 Starting HMR WebSocket bridge...');
+        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}`);
+    }
+    handleViteHMRMessage(data) {
+        if (!data || typeof data !== 'object')
+            return;
+        // Filter out irrelevant file changes
+        if (data.updates) {
+            const relevantUpdates = data.updates.filter(update => {
+                const path = update.path || '';
+                return (path.includes('/src/') ||
+                    path.endsWith('package.json') ||
+                    path.endsWith('vite.config.ts') ||
+                    path.endsWith('tsconfig.json') ||
+                    path.endsWith('nativescript.config.ts'));
+            });
+            if (relevantUpdates.length === 0) {
+                console.log('🔥 Ignoring HMR update for non-src files');
+                return; // Skip if no relevant updates
+            }
+            data.updates = relevantUpdates;
+        }
+        console.log('🔥 Vite HMR update:', data);
+        // Transform Vite HMR message to NativeScript format
+        let hmrUpdate;
+        if (data.type === 'update') {
+            // CSS updates
+            const cssUpdates = data.updates?.filter(u => u.path.endsWith('.css') || u.path.endsWith('.scss'));
+            if (cssUpdates?.length > 0) {
+                hmrUpdate = {
+                    type: 'css-update',
+                    path: cssUpdates[0].path,
+                    timestamp: Date.now(),
+                    updates: cssUpdates
+                };
+            }
+            // JS/TS updates
+            else {
+                hmrUpdate = {
+                    type: 'js-update',
+                    timestamp: Date.now(),
+                    updates: data.updates
+                };
+            }
+        }
+        else if (data.type === 'full-reload') {
+            hmrUpdate = {
+                type: 'full-reload',
+                timestamp: Date.now()
+            };
+        }
+        else {
+            return; // Ignore other message types
+        }
+        // Broadcast to connected NativeScript clients
+        this.broadcastToClients(hmrUpdate);
+    }
+    broadcastToClients(update) {
+        const message = JSON.stringify(update);
+        let sentCount = 0;
+        this.connectedClients.forEach((client) => {
+            if (client.readyState === WebSocket.OPEN) {
+                client.send(message);
+                sentCount++;
+            }
+        });
+        console.log(`🔥 Broadcasted ${update.type} to ${sentCount} clients`);
+    }
+    async startBuildProcess() {
+        // This runs the traditional build process for initial bundle creation
+        // but won't be used for HMR - that's handled by the dev server
+        console.log('🔥 Starting initial build process...');
+        // We might not need this if we can serve directly from Vite dev server
+        // But keeping it for compatibility with NativeScript CLI expectations
+    }
+    async stop() {
+        console.log('🔥 Stopping HMR server...');
+        if (this.viteServer) {
+            await this.viteServer.close();
+        }
+        if (this.wsServer) {
+            this.wsServer.close();
+        }
+        if (this.buildProcess) {
+            this.buildProcess.kill();
+        }
+    }
+}
+// CLI interface
+async function main() {
+    const hmrServer = new NativeScriptHMRServer();
+    // Handle graceful shutdown
+    process.on('SIGINT', async () => {
+        await hmrServer.stop();
+        process.exit(0);
+    });
+    process.on('SIGTERM', async () => {
+        await hmrServer.stop();
+        process.exit(0);
+    });
+    await hmrServer.start();
+}
+// Export for use in other contexts
+export { NativeScriptHMRServer };
+// Run if called directly
+// if (require.main === module) {
+//   main().catch(console.error);
+// }

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './configuration/base.js';
+export * from './configuration/angular.js';
+export * from './configuration/react.js';
+export * from './configuration/solid.js';
+export * from './configuration/vue.js';

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from './configuration/base.js';
+export * from './configuration/angular.js';
+export * from './configuration/react.js';
+export * from './configuration/solid.js';
+export * from './configuration/vue.js';

package/dist/polyfills/mdn-data-at-rules.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Mock for mdn-data/css/at-rules.json
+ * Returns empty object since css-tree has its own comprehensive data
+ * This prevents css-tree from failing when trying to patch its data
+ */
+declare const _default: {};
+export default _default;

package/dist/polyfills/mdn-data-at-rules.js

@@ -0,0 +1,7 @@
+/**
+ * Mock for mdn-data/css/at-rules.json
+ * Returns empty object since css-tree has its own comprehensive data
+ * This prevents css-tree from failing when trying to patch its data
+ */
+// Return empty object - css-tree will use its built-in data instead
+export default {};

package/dist/polyfills/mdn-data-properties.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Mock for mdn-data/css/properties.json
+ * Returns empty object since css-tree has its own comprehensive data
+ * This prevents css-tree from failing when trying to patch its data
+ */
+declare const _default: {};
+export default _default;

package/dist/polyfills/mdn-data-properties.js

@@ -0,0 +1,7 @@
+/**
+ * Mock for mdn-data/css/properties.json
+ * Returns empty object since css-tree has its own comprehensive data
+ * This prevents css-tree from failing when trying to patch its data
+ */
+// Return empty object - css-tree will use its built-in data instead
+export default {};

package/dist/polyfills/mdn-data-syntaxes.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Mock for mdn-data/css/syntaxes.json
+ * Returns empty object since css-tree has its own comprehensive data
+ * This prevents css-tree from failing when trying to patch its data
+ */
+declare const _default: {};
+export default _default;

package/dist/polyfills/mdn-data-syntaxes.js

@@ -0,0 +1,7 @@
+/**
+ * Mock for mdn-data/css/syntaxes.json
+ * Returns empty object since css-tree has its own comprehensive data
+ * This prevents css-tree from failing when trying to patch its data
+ */
+// Return empty object - css-tree will use its built-in data instead
+export default {};

package/dist/polyfills/module.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Polyfill for Node.js 'module' built-in
+ * Provides minimal implementation for NativeScript environment
+ */
+export declare function createRequire(filename: string): (id: string) => {
+    atrules: {};
+    properties: {};
+    types: {};
+} | {
+    atrules?: undefined;
+    properties?: undefined;
+    types?: undefined;
+};
+declare const _default: {
+    createRequire: typeof createRequire;
+};
+export default _default;

package/dist/polyfills/module.js

@@ -0,0 +1,29 @@
+/**
+ * Polyfill for Node.js 'module' built-in
+ * Provides minimal implementation for NativeScript environment
+ */
+// Mock createRequire function that css-tree uses
+export function createRequire(filename) {
+    // Return a mock require function
+    return function mockRequire(id) {
+        // Handle css-tree's internal patch.json file
+        if (id.includes('../data/patch.json') || id.includes('patch.json')) {
+            // Return css-tree's patch structure
+            return {
+                atrules: {},
+                properties: {},
+                types: {},
+            };
+        }
+        // For mdn-data files, return empty objects
+        if (id.includes('mdn-data')) {
+            return {};
+        }
+        // For any other requires, return empty object
+        return {};
+    };
+}
+// Also export as default for compatibility
+export default {
+    createRequire: createRequire,
+};

package/dist/shims/react-reconciler-constants.d.ts

@@ -0,0 +1,14 @@
+export declare const DefaultEventPriority = 16;
+export declare const DiscreteEventPriority = 1;
+export declare const ContinuousEventPriority = 4;
+export declare const IdleEventPriority = 268435456;
+export declare const ConcurrentMode = 1;
+export declare const ProfileMode = 2;
+export declare const StrictMode = 8;
+export declare const NoMode = 0;
+export declare const BlockingMode = 2;
+export declare const DebugTracingMode = 4;
+export declare const StrictLegacyMode = 16;
+export declare const StrictEffectsMode = 32;
+export declare const LegacyRoot = 0;
+export declare const ConcurrentRoot = 1;

package/dist/shims/react-reconciler-constants.js

@@ -0,0 +1,20 @@
+// Shim for react-reconciler/constants.js to handle missing exports
+// This addresses the issue where react-nativescript tries to import 
+// exports that don't exist in the current version of react-reconciler
+// Event priorities (these are the primary values react-nativescript needs)
+export const DefaultEventPriority = 16;
+export const DiscreteEventPriority = 1;
+export const ContinuousEventPriority = 4;
+export const IdleEventPriority = 268435456;
+// Mode constants
+export const ConcurrentMode = 1;
+export const ProfileMode = 2;
+export const StrictMode = 8;
+export const NoMode = 0;
+export const BlockingMode = 2;
+export const DebugTracingMode = 4;
+export const StrictLegacyMode = 16;
+export const StrictEffectsMode = 32;
+// Root modes (required by react-nativescript)
+export const LegacyRoot = 0;
+export const ConcurrentRoot = 1;

package/dist/shims/react-reconciler.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Shim for react-reconciler to fix namespace call issues
+ * This resolves the "Cannot call a namespace" error
+ */
+declare const ReactReconciler: any;
+export * from 'react-reconciler';
+export default ReactReconciler;
+export { ReactReconciler };

package/dist/shims/react-reconciler.js

@@ -0,0 +1,14 @@
+/**
+ * Shim for react-reconciler to fix namespace call issues
+ * This resolves the "Cannot call a namespace" error
+ */
+// Import the actual reconciler
+import * as ReactReconcilerModule from 'react-reconciler';
+// Export the reconciler as a callable function, not a namespace
+const ReactReconciler = ReactReconcilerModule.default || ReactReconcilerModule;
+// Re-export everything from the module
+export * from 'react-reconciler';
+// Export the main reconciler function
+export default ReactReconciler;
+// Also export as named export for compatibility
+export { ReactReconciler };

package/dist/shims/set-value.d.ts

@@ -0,0 +1,4 @@
+/**
+ * shim for set-value commonjs package export
+ */
+export default function setValue(obj: any, path: any, value: any): any;

package/dist/shims/set-value.js

@@ -0,0 +1,21 @@
+/**
+ * shim for set-value commonjs package export
+ */
+export default function setValue(obj, path, value) {
+    if (!obj)
+        return obj;
+    const parts = Array.isArray(path)
+        ? path
+        : String(path).replace(/\[(\d+)\]/g, '.$1').split('.').filter(Boolean);
+    let cur = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const k = parts[i];
+        const next = parts[i + 1];
+        if (cur[k] == null || typeof cur[k] !== 'object') {
+            cur[k] = /^\d+$/.test(next) ? [] : {};
+        }
+        cur = cur[k];
+    }
+    cur[parts[parts.length - 1]] = value;
+    return obj;
+}

package/dist/transformers/NativeClass/index.d.ts

@@ -0,0 +1,5 @@
+import ts from 'typescript';
+/**
+ * A TypeScript transform that compiles classes marked with `@NativeClass` as es5
+ */
+export default function (ctx: ts.TransformationContext): (source: ts.SourceFile) => ts.SourceFile;