@zap-js/client 0.0.2 → 0.0.4

package/dist/dev-server/vite-proxy.d.ts

@@ -0,0 +1,56 @@
+import { EventEmitter } from 'events';
+export interface ViteProxyConfig {
+    projectDir: string;
+    port?: number;
+    host?: string;
+    configFile?: string;
+}
+export type ViteStatus = 'stopped' | 'starting' | 'running' | 'error';
+/**
+ * ViteProxy - Manages Vite dev server for frontend development
+ *
+ * Features:
+ * - Automatic Vite dev server lifecycle management
+ * - Port detection and configuration
+ * - HMR support passthrough
+ * - Error handling and restart
+ */
+export declare class ViteProxy extends EventEmitter {
+    private config;
+    private process;
+    private status;
+    private actualPort;
+    constructor(config: ViteProxyConfig);
+    /**
+     * Get current status
+     */
+    getStatus(): ViteStatus;
+    /**
+     * Get the port Vite is running on
+     */
+    getPort(): number | null;
+    /**
+     * Start Vite dev server
+     */
+    start(): Promise<void>;
+    /**
+     * Stop Vite dev server
+     */
+    stop(): Promise<void>;
+    /**
+     * Restart Vite dev server
+     */
+    restart(): Promise<void>;
+    /**
+     * Check if Vite is healthy
+     */
+    healthCheck(): Promise<boolean>;
+    /**
+     * Detect the best package runner available
+     */
+    private detectPackageRunner;
+    /**
+     * Get the base URL for the Vite server
+     */
+    getBaseUrl(): string | null;
+}

package/dist/dev-server/vite-proxy.js

@@ -0,0 +1,212 @@
+import { spawn, execSync } from 'child_process';
+import { EventEmitter } from 'events';
+import http from 'http';
+/**
+ * ViteProxy - Manages Vite dev server for frontend development
+ *
+ * Features:
+ * - Automatic Vite dev server lifecycle management
+ * - Port detection and configuration
+ * - HMR support passthrough
+ * - Error handling and restart
+ */
+export class ViteProxy extends EventEmitter {
+    constructor(config) {
+        super();
+        this.process = null;
+        this.status = 'stopped';
+        this.actualPort = null;
+        this.config = {
+            port: 5173,
+            host: '127.0.0.1',
+            ...config,
+        };
+    }
+    /**
+     * Get current status
+     */
+    getStatus() {
+        return this.status;
+    }
+    /**
+     * Get the port Vite is running on
+     */
+    getPort() {
+        return this.actualPort;
+    }
+    /**
+     * Start Vite dev server
+     */
+    async start() {
+        if (this.status === 'running') {
+            return;
+        }
+        this.status = 'starting';
+        this.emit('starting');
+        return new Promise((resolve, reject) => {
+            const args = [
+                'vite',
+                '--port', String(this.config.port),
+                '--host', this.config.host,
+                '--strictPort',
+            ];
+            if (this.config.configFile) {
+                args.push('--config', this.config.configFile);
+            }
+            // Try to use bunx first, fall back to npx
+            const runner = this.detectPackageRunner();
+            console.log(`[vite-proxy] Starting with: ${runner} ${args.join(' ')}`);
+            console.log(`[vite-proxy] Working directory: ${this.config.projectDir}`);
+            this.process = spawn(runner, args, {
+                cwd: this.config.projectDir,
+                stdio: ['ignore', 'pipe', 'pipe'],
+                env: {
+                    ...process.env,
+                    FORCE_COLOR: '1',
+                },
+            });
+            let startupComplete = false;
+            this.process.stdout?.on('data', (data) => {
+                const output = data.toString();
+                console.log(`[vite-proxy stdout] ${output.trim()}`);
+                this.emit('output', output);
+                // Detect when Vite is ready - check multiple patterns
+                const isReady = output.includes('Local:') ||
+                    output.includes('ready in') ||
+                    output.includes('VITE') && output.includes('localhost');
+                if (!startupComplete && isReady) {
+                    startupComplete = true;
+                    this.status = 'running';
+                    // Parse actual port from output - try multiple patterns
+                    const portMatch = output.match(/localhost:(\d+)/) ||
+                        output.match(/127\.0\.0\.1:(\d+)/) ||
+                        output.match(/:(\d+)\//);
+                    if (portMatch) {
+                        this.actualPort = parseInt(portMatch[1], 10);
+                    }
+                    else {
+                        this.actualPort = this.config.port;
+                    }
+                    console.log(`[vite-proxy] Ready on port ${this.actualPort}`);
+                    this.emit('ready', this.actualPort);
+                    resolve();
+                }
+                // Detect HMR updates
+                if (output.includes('[vite] hmr update')) {
+                    this.emit('hmr-update');
+                }
+            });
+            this.process.stderr?.on('data', (data) => {
+                const output = data.toString();
+                console.log(`[vite-proxy stderr] ${output.trim()}`);
+                this.emit('stderr', output);
+                // Check for critical errors (but not just any lowercase 'error')
+                if (output.includes('Error:') || output.includes('EADDRINUSE')) {
+                    this.emit('error', new Error(output));
+                }
+            });
+            this.process.on('close', (code) => {
+                console.log(`[vite-proxy] Process closed with code ${code}`);
+                const wasRunning = this.status === 'running';
+                this.status = 'stopped';
+                this.actualPort = null;
+                this.process = null;
+                if (wasRunning && code !== 0) {
+                    this.emit('crash', code);
+                }
+                this.emit('exit', code);
+                if (!startupComplete) {
+                    reject(new Error(`Vite exited with code ${code} before starting`));
+                }
+            });
+            this.process.on('error', (err) => {
+                console.log(`[vite-proxy] Process error: ${err.message}`);
+                this.status = 'error';
+                this.emit('error', err);
+                reject(err);
+            });
+            // Timeout for startup
+            setTimeout(() => {
+                if (!startupComplete) {
+                    console.log(`[vite-proxy] Startup timeout - still waiting...`);
+                    this.emit('timeout');
+                    // Don't reject - Vite might still be starting
+                }
+            }, 30000);
+        });
+    }
+    /**
+     * Stop Vite dev server
+     */
+    async stop() {
+        if (!this.process) {
+            return;
+        }
+        return new Promise((resolve) => {
+            if (!this.process) {
+                resolve();
+                return;
+            }
+            const timeout = setTimeout(() => {
+                if (this.process && !this.process.killed) {
+                    this.process.kill('SIGKILL');
+                }
+            }, 5000);
+            this.process.once('exit', () => {
+                clearTimeout(timeout);
+                this.process = null;
+                this.status = 'stopped';
+                this.actualPort = null;
+                resolve();
+            });
+            this.process.kill('SIGTERM');
+        });
+    }
+    /**
+     * Restart Vite dev server
+     */
+    async restart() {
+        await this.stop();
+        await this.start();
+    }
+    /**
+     * Check if Vite is healthy
+     */
+    async healthCheck() {
+        if (!this.actualPort || this.status !== 'running') {
+            return false;
+        }
+        return new Promise((resolve) => {
+            const req = http.get(`http://${this.config.host}:${this.actualPort}/`, { timeout: 2000 }, (res) => {
+                resolve(res.statusCode === 200);
+            });
+            req.on('error', () => resolve(false));
+            req.on('timeout', () => {
+                req.destroy();
+                resolve(false);
+            });
+        });
+    }
+    /**
+     * Detect the best package runner available
+     */
+    detectPackageRunner() {
+        // Check if bun is available
+        try {
+            execSync('bun --version', { stdio: 'ignore' });
+            return 'bunx';
+        }
+        catch {
+            return 'npx';
+        }
+    }
+    /**
+     * Get the base URL for the Vite server
+     */
+    getBaseUrl() {
+        if (!this.actualPort) {
+            return null;
+        }
+        return `http://${this.config.host}:${this.actualPort}`;
+    }
+}

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

@@ -0,0 +1,48 @@
+import { EventEmitter } from 'events';
+export type WatchEventType = 'add' | 'change' | 'unlink';
+export interface WatchEvent {
+    type: WatchEventType;
+    path: string;
+    category: 'rust' | 'typescript' | 'config' | 'unknown';
+}
+export interface WatcherConfig {
+    rootDir: string;
+    rustDirs?: string[];
+    tsDirs?: string[];
+    ignored?: string[];
+}
+/**
+ * FileWatcher - Monitors file changes and categorizes them
+ *
+ * Watches for:
+ * - Rust source changes (.rs, Cargo.toml)
+ * - TypeScript/JS changes (.ts, .tsx, .js, .jsx)
+ * - Config changes (package.json, tsconfig.json, vite.config.*)
+ */
+export declare class FileWatcher extends EventEmitter {
+    private watcher;
+    private config;
+    private debounceTimers;
+    private debounceMs;
+    constructor(config: WatcherConfig);
+    /**
+     * Start watching for file changes
+     */
+    start(): void;
+    /**
+     * Stop watching
+     */
+    stop(): Promise<void>;
+    /**
+     * Handle a file event with debouncing
+     */
+    private handleEvent;
+    /**
+     * Categorize a file based on its extension
+     */
+    private categorizeFile;
+    /**
+     * Set debounce timing
+     */
+    setDebounce(ms: number): void;
+}

package/dist/dev-server/watcher.js

@@ -0,0 +1,127 @@
+import chokidar from 'chokidar';
+import { EventEmitter } from 'events';
+import path from 'path';
+/**
+ * FileWatcher - Monitors file changes and categorizes them
+ *
+ * Watches for:
+ * - Rust source changes (.rs, Cargo.toml)
+ * - TypeScript/JS changes (.ts, .tsx, .js, .jsx)
+ * - Config changes (package.json, tsconfig.json, vite.config.*)
+ */
+export class FileWatcher extends EventEmitter {
+    constructor(config) {
+        super();
+        this.watcher = null;
+        this.debounceTimers = new Map();
+        this.debounceMs = 100;
+        this.config = {
+            rustDirs: ['src', 'packages'],
+            tsDirs: ['src', 'packages'],
+            ignored: [
+                '**/node_modules/**',
+                '**/target/**',
+                '**/dist/**',
+                '**/.git/**',
+                '**/build/**',
+                '**/*.d.ts',
+            ],
+            ...config,
+        };
+    }
+    /**
+     * Start watching for file changes
+     */
+    start() {
+        const watchPaths = [
+            // Rust files
+            path.join(this.config.rootDir, '**/*.rs'),
+            path.join(this.config.rootDir, '**/Cargo.toml'),
+            // TypeScript files
+            path.join(this.config.rootDir, '**/*.ts'),
+            path.join(this.config.rootDir, '**/*.tsx'),
+            path.join(this.config.rootDir, '**/*.js'),
+            path.join(this.config.rootDir, '**/*.jsx'),
+            // Config files
+            path.join(this.config.rootDir, '**/package.json'),
+            path.join(this.config.rootDir, '**/tsconfig.json'),
+            path.join(this.config.rootDir, '**/vite.config.*'),
+        ];
+        this.watcher = chokidar.watch(watchPaths, {
+            ignored: this.config.ignored,
+            persistent: true,
+            ignoreInitial: true,
+            awaitWriteFinish: {
+                stabilityThreshold: 50,
+                pollInterval: 10,
+            },
+        });
+        this.watcher.on('add', (filePath) => this.handleEvent('add', filePath));
+        this.watcher.on('change', (filePath) => this.handleEvent('change', filePath));
+        this.watcher.on('unlink', (filePath) => this.handleEvent('unlink', filePath));
+        this.watcher.on('error', (error) => this.emit('error', error));
+        this.watcher.on('ready', () => this.emit('ready'));
+    }
+    /**
+     * Stop watching
+     */
+    async stop() {
+        if (this.watcher) {
+            await this.watcher.close();
+            this.watcher = null;
+        }
+        // Clear all debounce timers
+        for (const timer of this.debounceTimers.values()) {
+            clearTimeout(timer);
+        }
+        this.debounceTimers.clear();
+    }
+    /**
+     * Handle a file event with debouncing
+     */
+    handleEvent(type, filePath) {
+        // Debounce rapid changes to the same file
+        const existingTimer = this.debounceTimers.get(filePath);
+        if (existingTimer) {
+            clearTimeout(existingTimer);
+        }
+        const timer = setTimeout(() => {
+            this.debounceTimers.delete(filePath);
+            const event = {
+                type,
+                path: filePath,
+                category: this.categorizeFile(filePath),
+            };
+            this.emit('change', event);
+            this.emit(event.category, event);
+        }, this.debounceMs);
+        this.debounceTimers.set(filePath, timer);
+    }
+    /**
+     * Categorize a file based on its extension
+     */
+    categorizeFile(filePath) {
+        const ext = path.extname(filePath).toLowerCase();
+        const basename = path.basename(filePath);
+        // Rust files
+        if (ext === '.rs' || basename === 'Cargo.toml') {
+            return 'rust';
+        }
+        // TypeScript/JavaScript files
+        if (['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'].includes(ext)) {
+            return 'typescript';
+        }
+        // Config files
+        if (['package.json', 'tsconfig.json'].includes(basename) ||
+            basename.startsWith('vite.config.')) {
+            return 'config';
+        }
+        return 'unknown';
+    }
+    /**
+     * Set debounce timing
+     */
+    setDebounce(ms) {
+        this.debounceMs = ms;
+    }
+}

package/dist/router/codegen-enhanced.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Enhanced Route Code Generator with Layout Support
+ */
+import type { CodegenOptions } from './types.js';
+export declare function generateEnhancedRouteTree(options: CodegenOptions): void;