@zap-js/client 0.0.2 → 0.0.4

package/dist/dev-server/hot-reload.js

@@ -0,0 +1,280 @@
+import { WebSocketServer, WebSocket } from 'ws';
+import { EventEmitter } from 'events';
+import http from 'http';
+/**
+ * HotReloadServer - WebSocket server for hot reload signaling
+ *
+ * Broadcasts reload signals to connected clients:
+ * - Full page reload for Rust changes
+ * - Partial reload for TypeScript changes (Vite HMR handles this)
+ * - Config reload notifications
+ */
+export class HotReloadServer extends EventEmitter {
+    constructor(config = {}) {
+        super();
+        this.wss = null;
+        this.httpServer = null;
+        this.clients = new Set();
+        this.config = {
+            port: 3001,
+            host: '127.0.0.1',
+            ...config,
+        };
+    }
+    /**
+     * Start the hot reload WebSocket server
+     */
+    async start() {
+        return new Promise((resolve, reject) => {
+            this.httpServer = http.createServer((req, res) => {
+                // Simple health check endpoint
+                if (req.url === '/health') {
+                    res.writeHead(200, { 'Content-Type': 'text/plain' });
+                    res.end('OK');
+                    return;
+                }
+                // Serve a simple client script
+                if (req.url === '/client.js') {
+                    res.writeHead(200, { 'Content-Type': 'application/javascript' });
+                    res.end(this.getClientScript());
+                    return;
+                }
+                res.writeHead(404);
+                res.end();
+            });
+            this.wss = new WebSocketServer({ server: this.httpServer });
+            this.wss.on('connection', (ws, req) => {
+                this.clients.add(ws);
+                this.emit('client-connected', req.socket.remoteAddress);
+                // Send welcome message
+                this.send(ws, {
+                    type: 'connected',
+                    message: 'Connected to ZapRS hot reload server',
+                    timestamp: Date.now(),
+                });
+                ws.on('close', () => {
+                    this.clients.delete(ws);
+                    this.emit('client-disconnected');
+                });
+                ws.on('error', (err) => {
+                    this.emit('client-error', err);
+                    this.clients.delete(ws);
+                });
+            });
+            this.wss.on('error', (err) => {
+                this.emit('error', err);
+                reject(err);
+            });
+            this.httpServer.listen(this.config.port, this.config.host, () => {
+                this.emit('ready', this.config.port);
+                resolve();
+            });
+            this.httpServer.on('error', reject);
+        });
+    }
+    /**
+     * Stop the server
+     */
+    async stop() {
+        // Close all client connections
+        for (const client of this.clients) {
+            client.close(1000, 'Server shutting down');
+        }
+        this.clients.clear();
+        // Close WebSocket server
+        if (this.wss) {
+            await new Promise((resolve) => {
+                this.wss.close(() => resolve());
+            });
+            this.wss = null;
+        }
+        // Close HTTP server
+        if (this.httpServer) {
+            await new Promise((resolve) => {
+                this.httpServer.close(() => resolve());
+            });
+            this.httpServer = null;
+        }
+    }
+    /**
+     * Broadcast a reload signal to all clients
+     */
+    reload(target, files) {
+        const message = {
+            type: 'reload',
+            target,
+            files,
+            timestamp: Date.now(),
+        };
+        this.broadcast(message);
+    }
+    /**
+     * Broadcast an update signal (partial reload)
+     */
+    update(files) {
+        const message = {
+            type: 'update',
+            files,
+            timestamp: Date.now(),
+        };
+        this.broadcast(message);
+    }
+    /**
+     * Broadcast an error message
+     */
+    notifyError(errorMessage) {
+        const message = {
+            type: 'error',
+            message: errorMessage,
+            timestamp: Date.now(),
+        };
+        this.broadcast(message);
+    }
+    /**
+     * Broadcast a message to all connected clients
+     */
+    broadcast(message) {
+        const json = JSON.stringify(message);
+        for (const client of this.clients) {
+            if (client.readyState === WebSocket.OPEN) {
+                client.send(json);
+            }
+        }
+        this.emit('broadcast', message);
+    }
+    /**
+     * Send a message to a specific client
+     */
+    send(ws, message) {
+        if (ws.readyState === WebSocket.OPEN) {
+            ws.send(JSON.stringify(message));
+        }
+    }
+    /**
+     * Get the number of connected clients
+     */
+    getClientCount() {
+        return this.clients.size;
+    }
+    /**
+     * Get the hot reload server URL
+     */
+    getUrl() {
+        return `ws://${this.config.host}:${this.config.port}`;
+    }
+    /**
+     * Get the client script for browser injection
+     */
+    getClientScript() {
+        return `
+(function() {
+  const WS_URL = 'ws://${this.config.host}:${this.config.port}';
+  let ws;
+  let reconnectAttempts = 0;
+  const maxReconnectAttempts = 10;
+
+  function connect() {
+    ws = new WebSocket(WS_URL);
+
+    ws.onopen = function() {
+      console.log('[ZapRS] Hot reload connected');
+      reconnectAttempts = 0;
+    };
+
+    ws.onmessage = function(event) {
+      try {
+        const data = JSON.parse(event.data);
+        handleMessage(data);
+      } catch (e) {
+        console.error('[ZapRS] Failed to parse message:', e);
+      }
+    };
+
+    ws.onclose = function() {
+      console.log('[ZapRS] Hot reload disconnected');
+      attemptReconnect();
+    };
+
+    ws.onerror = function(err) {
+      console.error('[ZapRS] WebSocket error:', err);
+    };
+  }
+
+  function handleMessage(data) {
+    switch (data.type) {
+      case 'connected':
+        console.log('[ZapRS]', data.message);
+        break;
+      case 'reload':
+        console.log('[ZapRS] Reloading:', data.target);
+        if (data.target === 'rust' || data.target === 'full') {
+          window.location.reload();
+        }
+        break;
+      case 'update':
+        console.log('[ZapRS] Files updated:', data.files);
+        // Vite HMR handles partial updates
+        break;
+      case 'error':
+        console.error('[ZapRS] Build error:', data.message);
+        showErrorOverlay(data.message);
+        break;
+    }
+  }
+
+  function showErrorOverlay(message) {
+    const existing = document.getElementById('zap-error-overlay');
+    if (existing) existing.remove();
+
+    const overlay = document.createElement('div');
+    overlay.id = 'zap-error-overlay';
+    overlay.style.cssText = \`
+      position: fixed;
+      top: 0;
+      left: 0;
+      right: 0;
+      bottom: 0;
+      background: rgba(0,0,0,0.9);
+      color: #ff6b6b;
+      font-family: monospace;
+      padding: 20px;
+      z-index: 99999;
+      overflow: auto;
+      white-space: pre-wrap;
+    \`;
+    overlay.innerHTML = \`
+      <div style="max-width: 800px; margin: 0 auto;">
+        <h2 style="color: #ff6b6b;">Build Error</h2>
+        <pre style="background: #1a1a1a; padding: 15px; border-radius: 4px;">\${escapeHtml(message)}</pre>
+        <button onclick="this.parentElement.parentElement.remove()" style="margin-top: 10px; padding: 8px 16px; cursor: pointer;">
+          Dismiss
+        </button>
+      </div>
+    \`;
+    document.body.appendChild(overlay);
+  }
+
+  function escapeHtml(text) {
+    const div = document.createElement('div');
+    div.textContent = text;
+    return div.innerHTML;
+  }
+
+  function attemptReconnect() {
+    if (reconnectAttempts < maxReconnectAttempts) {
+      reconnectAttempts++;
+      setTimeout(connect, 1000 * reconnectAttempts);
+    }
+  }
+
+  connect();
+})();
+`;
+    }
+    /**
+     * Get an HTML script tag for the client
+     */
+    getScriptTag() {
+        return `<script src="http://${this.config.host}:${this.config.port}/client.js"></script>`;
+    }
+}

package/dist/dev-server/index.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+export { DevServer, type DevServerConfig } from './server.js';
+export { FileWatcher, type WatchEvent } from './watcher.js';
+export { RustBuilder } from './rust-builder.js';
+export { ViteProxy } from './vite-proxy.js';
+export { HotReloadServer } from './hot-reload.js';
+export { CodegenRunner } from './codegen-runner.js';
+export { RouteScannerRunner } from './route-scanner.js';

package/dist/dev-server/index.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+export { DevServer } from './server.js';
+export { FileWatcher } from './watcher.js';
+export { RustBuilder } from './rust-builder.js';
+export { ViteProxy } from './vite-proxy.js';
+export { HotReloadServer } from './hot-reload.js';
+export { CodegenRunner } from './codegen-runner.js';
+export { RouteScannerRunner } from './route-scanner.js';

package/dist/dev-server/route-scanner.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Route scanner integration for dev server
+ *
+ * Watches the routes directory and regenerates route tree on changes
+ */
+import { EventEmitter } from 'events';
+interface RouteTree {
+    routes: Array<{
+        filePath: string;
+        relativePath: string;
+        urlPath: string;
+        type: string;
+        params: Array<{
+            name: string;
+            index: number;
+            catchAll: boolean;
+        }>;
+        isIndex: boolean;
+    }>;
+    apiRoutes: Array<{
+        filePath: string;
+        relativePath: string;
+        urlPath: string;
+        type: string;
+        params: Array<{
+            name: string;
+            index: number;
+            catchAll: boolean;
+        }>;
+        methods?: string[];
+        isIndex: boolean;
+    }>;
+    layouts: unknown[];
+    root: unknown;
+}
+export interface RouteScannerConfig {
+    projectDir: string;
+    routesDir?: string;
+    outputDir?: string;
+}
+/**
+ * RouteScannerRunner - Runs the route scanner and generates route tree
+ */
+export declare class RouteScannerRunner extends EventEmitter {
+    private config;
+    private routesDir;
+    private outputDir;
+    private watcher;
+    constructor(config: RouteScannerConfig);
+    /**
+     * Try to load the router module
+     */
+    private loadRouter;
+    /**
+     * Scan routes once and generate output
+     */
+    scan(): Promise<RouteTree | null>;
+    /**
+     * Start watching for route changes
+     */
+    startWatching(): Promise<void>;
+    /**
+     * Stop watching
+     */
+    stopWatching(): Promise<void>;
+    /**
+     * Check if routes directory exists
+     */
+    hasRoutesDir(): boolean;
+}
+export {};

package/dist/dev-server/route-scanner.js

@@ -0,0 +1,114 @@
+/**
+ * Route scanner integration for dev server
+ *
+ * Watches the routes directory and regenerates route tree on changes
+ */
+import { EventEmitter } from 'events';
+import { existsSync, mkdirSync } from 'fs';
+import { join } from 'path';
+/**
+ * RouteScannerRunner - Runs the route scanner and generates route tree
+ */
+export class RouteScannerRunner extends EventEmitter {
+    constructor(config) {
+        super();
+        this.watcher = null;
+        this.config = config;
+        this.routesDir = config.routesDir || join(config.projectDir, 'routes');
+        this.outputDir = config.outputDir || join(config.projectDir, 'src', 'generated');
+    }
+    /**
+     * Try to load the router module
+     */
+    async loadRouter() {
+        try {
+            // Dynamic import using variable to prevent TypeScript from resolving at compile time
+            const moduleName = '@zapjs/router';
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const router = await (Function('moduleName', 'return import(moduleName)')(moduleName));
+            return router;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Scan routes once and generate output
+     */
+    async scan() {
+        if (!existsSync(this.routesDir)) {
+            return null;
+        }
+        try {
+            const router = await this.loadRouter();
+            if (!router) {
+                this.emit('error', new Error('@zapjs/router not installed'));
+                return null;
+            }
+            const tree = router.scanRoutes(this.routesDir);
+            // Ensure output directory exists
+            if (!existsSync(this.outputDir)) {
+                mkdirSync(this.outputDir, { recursive: true });
+            }
+            // Generate route tree
+            router.generateRouteTree({
+                outputDir: this.outputDir,
+                routeTree: tree,
+            });
+            this.emit('scan-complete', tree);
+            return tree;
+        }
+        catch (err) {
+            this.emit('error', err);
+            return null;
+        }
+    }
+    /**
+     * Start watching for route changes
+     */
+    async startWatching() {
+        if (!existsSync(this.routesDir)) {
+            return;
+        }
+        try {
+            const router = await this.loadRouter();
+            if (!router) {
+                return;
+            }
+            this.watcher = router.watchRoutes({
+                routesDir: this.routesDir,
+                skipInitial: true,
+                onChange: (tree) => {
+                    // Ensure output directory exists
+                    if (!existsSync(this.outputDir)) {
+                        mkdirSync(this.outputDir, { recursive: true });
+                    }
+                    router.generateRouteTree({
+                        outputDir: this.outputDir,
+                        routeTree: tree,
+                    });
+                    this.emit('routes-changed', tree);
+                },
+            });
+            this.emit('watching');
+        }
+        catch (err) {
+            this.emit('error', err);
+        }
+    }
+    /**
+     * Stop watching
+     */
+    async stopWatching() {
+        if (this.watcher) {
+            await this.watcher.stop();
+            this.watcher = null;
+        }
+    }
+    /**
+     * Check if routes directory exists
+     */
+    hasRoutesDir() {
+        return existsSync(this.routesDir);
+    }
+}

package/dist/dev-server/rust-builder.d.ts

@@ -0,0 +1,66 @@
+import { EventEmitter } from 'events';
+export type BuildStatus = 'idle' | 'building' | 'success' | 'failed';
+export interface BuildResult {
+    success: boolean;
+    duration: number;
+    errors: string[];
+    warnings: string[];
+}
+export interface RustBuilderConfig {
+    projectDir: string;
+    target?: string;
+    release?: boolean;
+    features?: string[];
+    bin?: string;
+    /** Path to pre-built binary (skips compilation) */
+    binaryPath?: string;
+}
+/**
+ * RustBuilder - Manages Rust compilation with incremental builds
+ *
+ * Features:
+ * - Incremental compilation using cargo's built-in caching
+ * - Error parsing and structured output
+ * - Build queueing to prevent concurrent builds
+ * - Automatic binary detection
+ */
+export declare class RustBuilder extends EventEmitter {
+    private config;
+    private currentBuild;
+    private buildQueued;
+    private status;
+    private lastBuildResult;
+    constructor(config: RustBuilderConfig);
+    /**
+     * Get current build status
+     */
+    getStatus(): BuildStatus;
+    /**
+     * Get last build result
+     */
+    getLastBuildResult(): BuildResult | null;
+    /**
+     * Trigger a build, queuing if one is in progress
+     */
+    build(): Promise<BuildResult>;
+    /**
+     * Run the actual cargo build
+     */
+    private runBuild;
+    /**
+     * Format a compiler message for display
+     */
+    private formatCompilerMessage;
+    /**
+     * Cancel current build if running
+     */
+    cancel(): void;
+    /**
+     * Check the project without building (faster)
+     */
+    check(): Promise<BuildResult>;
+    /**
+     * Get the path to the built binary
+     */
+    getBinaryPath(): string;
+}