@vesk/adapter 0.0.1

package/dist/dev-server.js

@@ -0,0 +1,358 @@
+import { readFileSync, existsSync, watch, statSync } from 'node:fs';
+import { resolve, extname, dirname } from 'node:path';
+import { createServer } from 'node:http';
+import { fileURLToPath } from 'node:url';
+import { transformSync } from './esbuild-fallback.js';
+import { build } from '@vesk/adapter/src/index';
+import { createHmrServer } from '@vesk/adapter/src/hmr';
+import { buildRuntimeCode } from '@vesk/adapter/src/client-bundle';
+const __dirname = dirname(fileURLToPath(import.meta.url));
+async function readBody(req) {
+    const chunks = [];
+    for await (const chunk of req)
+        chunks.push(chunk);
+    return Buffer.concat(chunks);
+}
+function makeWebRequest(nodeReq, url) {
+    const parsedUrl = new URL(url, `http://${nodeReq.headers.host || 'localhost'}`);
+    const method = nodeReq.method || 'GET';
+    let _bodyBuffer = null;
+    async function getBody() {
+        if (_bodyBuffer)
+            return _bodyBuffer;
+        const chunks = [];
+        for await (const chunk of nodeReq)
+            chunks.push(Buffer.from(chunk));
+        _bodyBuffer = Buffer.concat(chunks);
+        return _bodyBuffer;
+    }
+    const webRequest = new Request(parsedUrl, { method, headers: nodeReq.headers, body: null });
+    webRequest.json = async () => { try {
+        return JSON.parse((await getBody()).toString());
+    }
+    catch {
+        return null;
+    } };
+    webRequest.text = async () => (await getBody()).toString('utf-8');
+    webRequest.formData = async () => {
+        const body = await getBody();
+        const ct = String(nodeReq.headers['content-type'] || '');
+        if (ct.includes('multipart/form-data')) {
+            const temp = new Request('http://localhost', { method: 'POST', headers: nodeReq.headers, body: body });
+            return temp.formData();
+        }
+        const fd = new FormData();
+        if (ct.includes('x-www-form-urlencoded')) {
+            for (const [k, v] of new URLSearchParams(body.toString()).entries())
+                fd.append(k, v);
+        }
+        return fd;
+    };
+    webRequest.clone = () => webRequest;
+    return webRequest;
+}
+const MIME = {
+    '.svg': 'image/svg+xml', '.css': 'text/css', '.js': 'application/javascript',
+    '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
+    '.ico': 'image/x-icon', '.html': 'text/html', '.json': 'application/json',
+    '.woff': 'font/woff', '.woff2': 'font/woff2', '.wasm': 'application/wasm',
+};
+export async function startDevServer(appDir, options) {
+    const port = options?.port || 3000;
+    const devDir = resolve(appDir, '..', '.vesk', 'dev');
+    const publicDir = options?.publicDir || resolve(appDir, '..', 'public');
+    let componentMap = new Map();
+    const monorepoRouter = resolve(__dirname, '..', '..', 'compiler', 'dist', 'router.js');
+    const pkgRouter = resolve(appDir, '..', 'node_modules', '@vesk/compiler', 'router.js');
+    const routerPath = existsSync(monorepoRouter) ? monorepoRouter : (existsSync(pkgRouter) ? pkgRouter : null);
+    if (routerPath) {
+        const { scanComponents } = await import(routerPath);
+        const componentsDir = resolve(appDir, '..', 'components');
+        if (existsSync(componentsDir)) {
+            componentMap = scanComponents(componentsDir);
+        }
+    }
+    let config = null;
+    let lastBuild = 0;
+    let ssrVersion = Date.now();
+    let routeTree = [];
+    let runtimeBundle = '';
+    async function doBuild() {
+        const start = Date.now();
+        try {
+            const result = await build(appDir, { outDir: devDir, publicDir, hmr: true });
+            const configPath = resolve(devDir, 'config.json');
+            if (existsSync(configPath)) {
+                config = JSON.parse(readFileSync(configPath, 'utf-8'));
+            }
+            if (result)
+                routeTree = result.routeTree;
+            const monorepoRoot = resolve(__dirname, '..', '..', '..');
+            const runtimeDir = resolve(monorepoRoot, 'packages', 'runtime', 'dist');
+            runtimeBundle = buildRuntimeCode(runtimeDir);
+            lastBuild = Date.now();
+            console.error(`vesk dev: rebuilt in ${Date.now() - start}ms`);
+        }
+        catch (e) {
+            const message = e instanceof Error ? e.message : String(e);
+            console.error(`vesk dev: build error: ${message}`);
+        }
+    }
+    await doBuild();
+    const server = createServer(async (req, res) => {
+        const url = new URL(req.url || '/', `http://localhost:${port}`);
+        if (url.pathname === '/_vesk/hmr.js') {
+            const monorepoRoot = resolve(__dirname, '..', '..', '..');
+            const runtimeSrc = resolve(monorepoRoot, 'packages', 'runtime', 'dist');
+            const hmrJsPath = resolve(runtimeSrc, 'hmr-client.js');
+            const hmrTsPath = resolve(runtimeSrc, 'hmr-client.ts');
+            const hmrPath = existsSync(hmrJsPath) ? hmrJsPath : (existsSync(hmrTsPath) ? hmrTsPath : null);
+            if (hmrPath) {
+                let hmrContent = readFileSync(hmrPath, 'utf-8');
+                if (hmrPath.endsWith('.ts')) {
+                    hmrContent = transformSync(hmrContent, { loader: 'ts' }).code;
+                }
+                res.writeHead(200, { 'Content-Type': 'application/javascript' });
+                res.end(hmrContent);
+                return;
+            }
+        }
+        if (url.pathname === '/_vesk/runtime.js') {
+            res.writeHead(200, { 'Content-Type': 'application/javascript' });
+            res.end(runtimeBundle);
+            return;
+        }
+        if (url.pathname.startsWith('/_vesk/static/')) {
+            const relPath = url.pathname.replace('/_vesk/static/', '').replace(/\.\./g, '');
+            const staticPath = resolve(devDir, 'static', relPath);
+            if (!staticPath.startsWith(resolve(devDir, 'static'))) {
+                res.writeHead(403);
+                res.end('Forbidden');
+                return;
+            }
+            if (existsSync(staticPath) && statSync(staticPath).isFile()) {
+                const ext = extname(staticPath);
+                res.writeHead(200, { 'Content-Type': MIME[ext] || 'application/octet-stream' });
+                res.end(readFileSync(staticPath));
+                return;
+            }
+        }
+        if (url.pathname !== '/') {
+            const sanitized = url.pathname.replace(/\.\./g, '');
+            const sourcePath = resolve(publicDir, sanitized.slice(1));
+            if (sourcePath.startsWith(publicDir) && existsSync(sourcePath) && statSync(sourcePath).isFile()) {
+                const ext = extname(sourcePath);
+                res.writeHead(200, { 'Content-Type': MIME[ext] || 'application/octet-stream' });
+                res.end(readFileSync(sourcePath));
+                return;
+            }
+            const buildPublicDir = resolve(devDir, 'static', 'public');
+            const buildPath = resolve(buildPublicDir, sanitized.slice(1));
+            if (buildPath.startsWith(buildPublicDir) && existsSync(buildPath) && statSync(buildPath).isFile()) {
+                const ext = extname(buildPath);
+                res.writeHead(200, { 'Content-Type': MIME[ext] || 'application/octet-stream' });
+                res.end(readFileSync(buildPath));
+                return;
+            }
+        }
+        if (config && url.pathname.startsWith('/_vesk/action/')) {
+            const actionId = url.pathname.replace('/_vesk/action/', '');
+            const actionEntry = config.actions && config.actions.find(a => a.id === actionId);
+            if (actionEntry) {
+                const handlerPath = resolve(devDir, actionEntry.function);
+                if (existsSync(handlerPath)) {
+                    try {
+                        const mod = await import(`${handlerPath}?t=${ssrVersion}`);
+                        if (mod.handleAction) {
+                            const webRequest = makeWebRequest(req, url.href);
+                            const response = await mod.handleAction(webRequest, actionId);
+                            const body = await response.text();
+                            const headers = Object.fromEntries(response.headers);
+                            const contentType = headers['content-type'] || '';
+                            let finalBody = body;
+                            if (contentType.includes('text/html')) {
+                                finalBody = body.replace('</body>', '\t<script type="module" src="/_vesk/hmr.js"></script>\n</body>');
+                            }
+                            res.writeHead(response.status, headers);
+                            res.end(finalBody);
+                            return;
+                        }
+                    }
+                    catch (e) {
+                        res.writeHead(500, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ ok: false, error: e instanceof Error ? e.message : String(e) }));
+                        return;
+                    }
+                }
+            }
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ ok: false, error: 'Action not found' }));
+            return;
+        }
+        if (config && url.pathname.startsWith('/api')) {
+            const apiRoute = config.routes.find(r => r.type === 'api' && matchPath(r.path, url.pathname));
+            if (apiRoute) {
+                const handlerPath = resolve(devDir, apiRoute.function);
+                if (existsSync(handlerPath)) {
+                    try {
+                        const mod = await import(`${handlerPath}?t=${ssrVersion}`);
+                        const webRequest = makeWebRequest(req, url.href);
+                        const response = await mod.handle(webRequest);
+                        const body = await response.text();
+                        res.writeHead(response.status, Object.fromEntries(response.headers));
+                        res.end(body);
+                    }
+                    catch (e) {
+                        const message = e instanceof Error ? e.message : String(e);
+                        res.writeHead(500, { 'Content-Type': 'application/json' });
+                        res.end(JSON.stringify({ error: message }));
+                    }
+                    return;
+                }
+            }
+        }
+        if (config) {
+            const ssrRoute = config.routes.find(r => r.type === 'ssr' && matchPath(r.path, url.pathname));
+            if (ssrRoute) {
+                const handlerPath = resolve(devDir, ssrRoute.function);
+                if (existsSync(handlerPath)) {
+                    try {
+                        const mod = await import(`${handlerPath}?t=${ssrVersion}`);
+                        const webRequest = makeWebRequest(req, url.href);
+                        const response = await mod.handle(webRequest);
+                        const body = await response.text();
+                        const headers = Object.fromEntries(response.headers);
+                        const contentType = headers['content-type'] || '';
+                        let finalBody = body;
+                        if (contentType.includes('text/html')) {
+                            finalBody = body.replace('</body>', '\t<script type="module" src="/_vesk/hmr.js"></script>\n</body>');
+                        }
+                        res.writeHead(response.status, headers);
+                        res.end(finalBody);
+                    }
+                    catch (e) {
+                        res.writeHead(500, { 'Content-Type': 'text/html' });
+                        res.end('<!DOCTYPE html><html><body><h1>500</h1><pre>Internal Server Error</pre></body></html>');
+                    }
+                    return;
+                }
+            }
+        }
+        if (config) {
+            const rootRoute = config.routes.find(r => r.type === 'ssr' && r.path === '/');
+            if (rootRoute) {
+                const handlerPath = resolve(devDir, rootRoute.function);
+                if (existsSync(handlerPath)) {
+                    try {
+                        const mod = await import(`${handlerPath}?t=${ssrVersion}`);
+                        const webRequest = makeWebRequest(req, url.href);
+                        const response = await mod.handle(webRequest);
+                        const body = await response.text();
+                        const headers = Object.fromEntries(response.headers);
+                        const contentType = headers['content-type'] || '';
+                        let finalBody = body;
+                        if (contentType.includes('text/html')) {
+                            finalBody = body.replace('</body>', '\t<script type="module" src="/_vesk/hmr.js"></script>\n</body>');
+                        }
+                        res.writeHead(200, headers);
+                        res.end(finalBody);
+                    }
+                    catch (e) {
+                        res.writeHead(500, { 'Content-Type': 'text/html' });
+                        res.end('<!DOCTYPE html><html><body><h1>500</h1><pre>Internal Server Error</pre></body></html>');
+                    }
+                    return;
+                }
+            }
+        }
+        res.writeHead(404, { 'Content-Type': 'text/html' });
+        res.end('<!DOCTYPE html><html><body><h1>404</h1><p>Not Found</p></body></html>');
+    });
+    const hmr = createHmrServer(server, appDir, devDir, componentMap);
+    const srcDir = resolve(appDir, '..', 'src');
+    try {
+        if (existsSync(srcDir)) {
+            watch(srcDir, { recursive: true }, (_eventType, filename) => {
+                if (!filename)
+                    return;
+                if (filename.endsWith('.css')) {
+                    doBuild();
+                }
+            });
+        }
+    }
+    catch {
+        // src/ dir not available
+    }
+    let debounceTimer = null;
+    let pendingFiles = new Set();
+    try {
+        watch(appDir, { recursive: true }, (_eventType, filename) => {
+            if (!filename)
+                return;
+            if (debounceTimer)
+                clearTimeout(debounceTimer);
+            pendingFiles.add(filename);
+            debounceTimer = setTimeout(() => {
+                const files = [...pendingFiles];
+                pendingFiles = new Set();
+                const configFiles = files.filter(f => f === 'vesk.config.ts' || f === 'vesk.config.js' ||
+                    f === 'tsconfig.json' || f === 'package.json' ||
+                    f.endsWith('/vesk.config.ts') || f.endsWith('/vesk.config.js') ||
+                    f.endsWith('/tsconfig.json') || f.endsWith('/package.json'));
+                const apiMiddlewareFiles = files.filter(f => (f.includes('/api/') || f === 'middleware.ts' || f.endsWith('/middleware.ts')) &&
+                    (f.endsWith('.ts') || f.endsWith('.js')));
+                const vskFiles = files.filter(f => f.endsWith('.vsk'));
+                if (configFiles.length > 0) {
+                    hmr.handleFileChange(configFiles[0], doBuild, routeTree);
+                }
+                else if (apiMiddlewareFiles.length > 0) {
+                    hmr.handleFileChange(apiMiddlewareFiles[0], doBuild, routeTree);
+                }
+                else if (vskFiles.length > 0) {
+                    (async () => {
+                        for (const f of vskFiles) {
+                            await hmr.handleFileChange(f, doBuild, routeTree);
+                        }
+                        ssrVersion = Date.now();
+                    })();
+                }
+                else if (files.length > 0) {
+                    hmr.handleFileChange(files[0], doBuild, routeTree);
+                }
+            }, 200);
+        });
+    }
+    catch (e) {
+        console.error('vesk dev: file watching unavailable');
+    }
+    await new Promise(resolve => {
+        server.listen(port, () => {
+            console.error(`vesk dev server at http://localhost:${port}`);
+            resolve();
+        });
+    });
+    if (options?.block !== false) {
+        await new Promise(() => { });
+    }
+    return server;
+}
+function matchPath(pattern, pathname) {
+    const patternParts = pattern.split('/').filter(Boolean);
+    const pathParts = pathname.split('/').filter(Boolean);
+    let pi = 0, pp = 0;
+    while (pi < pathParts.length && pp < patternParts.length) {
+        if (patternParts[pp].startsWith(':')) {
+            pi++;
+            pp++;
+        }
+        else if (patternParts[pp] === pathParts[pi]) {
+            pi++;
+            pp++;
+        }
+        else {
+            return false;
+        }
+    }
+    return pp === patternParts.length && pi === pathParts.length;
+}

package/dist/esbuild-fallback.d.ts

@@ -0,0 +1,3 @@
+export declare function build(options: any): Promise<any>;
+export declare function transformSync(code: string, options?: any): any;
+//# sourceMappingURL=esbuild-fallback.d.ts.map

package/dist/esbuild-fallback.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"esbuild-fallback.d.ts","sourceRoot":"","sources":["../src/esbuild-fallback.ts"],"names":[],"mappings":"AA8BA,wBAAsB,KAAK,CAAC,OAAO,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAgBtD;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,GAAG,CAa9D"}

package/dist/esbuild-fallback.js

@@ -0,0 +1,64 @@
+let _nativeBuild = null;
+let _nativeTransform = null;
+let _wasm = null;
+let _wasmReady = null;
+async function loadNative() {
+    if (_nativeBuild && _nativeTransform)
+        return;
+    try {
+        const m = await import('esbuild');
+        _nativeBuild = m.build.bind(m);
+        _nativeTransform = m.transformSync.bind(m);
+    }
+    catch {
+        // native esbuild not installed
+    }
+}
+async function getWasm() {
+    if (_wasm)
+        return _wasm;
+    if (!_wasmReady) {
+        _wasmReady = import('esbuild-wasm').then(m => {
+            _wasm = m;
+            return m;
+        }).catch(() => {
+            _wasmReady = null;
+            throw new Error('esbuild-wasm not available');
+        });
+    }
+    return _wasmReady;
+}
+export async function build(options) {
+    await loadNative();
+    if (_nativeBuild) {
+        try {
+            return await _nativeBuild(options);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            if (msg.includes('SIGILL') || msg.includes('illegal hardware instruction') || msg.includes('cannot execute binary file')) {
+                console.warn('vesk: native esbuild failed, falling back to esbuild-wasm:', msg);
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    const wasm = await getWasm();
+    return wasm.build(options);
+}
+export function transformSync(code, options) {
+    if (_nativeTransform) {
+        try {
+            return _nativeTransform(code, options);
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            if (msg.includes('SIGILL') || msg.includes('illegal hardware instruction') || msg.includes('cannot execute binary file')) {
+                throw new Error('esbuild-wasm fallback for transformSync not yet implemented — use native esbuild or convert to async transform');
+            }
+            throw e;
+        }
+    }
+    throw new Error('esbuild not installed — run `npm install esbuild` or use `vesk build` which falls back to esbuild-wasm for bundling');
+}

package/dist/hmr.d.ts

@@ -0,0 +1,7 @@
+import type { Server } from 'node:http';
+import type { RouteNode } from '@vesk/adapter/src/types';
+export declare function createHmrServer(httpServer: Server, appDir: string, devDir: string, componentMap?: Map<string, string>): {
+    broadcast: (type: string, data?: Record<string, unknown>) => void;
+    handleFileChange: (filename: string | null, doFullBuild: () => Promise<void>, routeTree: RouteNode[]) => Promise<void>;
+};
+//# sourceMappingURL=hmr.d.ts.map

package/dist/hmr.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hmr.d.ts","sourceRoot":"","sources":["../src/hmr.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAOxC,OAAO,KAAK,EAAE,SAAS,EAAkB,MAAM,yBAAyB,CAAC;AA6RzE,wBAAgB,eAAe,CAC7B,UAAU,EAAE,MAAM,EAClB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,YAAY,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GACjC;IAAE,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;IAAC,gBAAgB,EAAE,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,EAAE,WAAW,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,EAAE,SAAS,EAAE,SAAS,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;CAAE,CAkH/L"}