vorzelajs 0.0.1

package/dist/server/index.js

@@ -0,0 +1,268 @@
+import { randomBytes } from 'node:crypto';
+import { serveStatic } from '@hono/node-server/serve-static';
+import { Hono } from 'hono';
+import { DEFAULT_ANALYTICS_ENDPOINT, handleAnalyticsRequest } from '../analytics';
+import { formatParsedStack, parseErrorStack } from '../debug/error-stack';
+import { isRedirect } from '../runtime/navigation';
+import { defaultRobotsConfig, renderRobotsTxt } from '../seo';
+function logDevRequest(kind, request, status, startedAt, isProd, meta = {}) {
+    if (isProd)
+        return;
+    const url = new URL(request.url);
+    const duration = Date.now() - startedAt;
+    const suffix = Object.entries(meta)
+        .filter(([, value]) => value !== undefined && value !== null && value !== '')
+        .map(([key, value]) => `${key}=${String(value)}`)
+        .join(' ');
+    console.info(`[VorzelaJs][dev] ${kind.padEnd(9)} ${request.method.padEnd(6)} ${String(status).padStart(3)} ${url.pathname}${url.search} ${duration}ms${suffix ? ` ${suffix}` : ''}`);
+}
+function logDevError(scope, error, isProd, meta = {}) {
+    if (isProd)
+        return;
+    const parsedStack = parseErrorStack(error);
+    console.groupCollapsed(`[VorzelaJs][dev:${scope}] ${error instanceof Error ? error.message : 'Unexpected error'}`);
+    console.info(meta);
+    if (parsedStack) {
+        const lines = formatParsedStack(parsedStack);
+        if (lines.length > 0) {
+            console.info(lines.join('\n'));
+        }
+    }
+    console.error(error);
+    console.groupEnd();
+}
+function escapeXml(value) {
+    return value
+        .replace(/&/gu, '&')
+        .replace(/</gu, '&lt;')
+        .replace(/>/gu, '&gt;')
+        .replace(/"/gu, '&quot;')
+        .replace(/'/gu, '&apos;');
+}
+export function createVorzelaApp(options) {
+    const { assets, isProd, loadEntry, staticRoot, vite } = options;
+    const app = new Hono();
+    // Static asset serving
+    if (isProd && staticRoot) {
+        app.use('/assets/*', serveStatic({ root: './dist/client' }));
+        app.use('/favicon.svg', serveStatic({ root: './dist/client' }));
+    }
+    if (!isProd) {
+        app.use('/favicon.svg', serveStatic({ root: './public' }));
+    }
+    const assetNotFound = (request) => {
+        const startedAt = Date.now();
+        logDevRequest('asset', request, 404, startedAt, isProd, { reason: 'missing-static-asset' });
+        return new Response('Asset Not Found', {
+            headers: {
+                'Cache-Control': 'no-store',
+                'Content-Type': 'text/plain; charset=utf-8',
+            },
+            status: 404,
+        });
+    };
+    if (isProd) {
+        app.all('/assets/*', (c) => assetNotFound(c.req.raw));
+    }
+    // Security headers
+    app.use('*', async (c, next) => {
+        const cspNonce = randomBytes(16).toString('base64');
+        c.set('cspNonce', cspNonce);
+        await next();
+        c.res.headers.set('X-Content-Type-Options', 'nosniff');
+        c.res.headers.set('X-Frame-Options', 'DENY');
+        c.res.headers.set('Referrer-Policy', 'strict-origin-when-cross-origin');
+        c.res.headers.set('Cross-Origin-Opener-Policy', 'same-origin');
+        c.res.headers.set('Cross-Origin-Resource-Policy', 'same-origin');
+        c.res.headers.set('Permissions-Policy', 'accelerometer=(), camera=(), geolocation=(), gyroscope=(), magnetometer=(), microphone=(), payment=(), usb=()');
+        c.res.headers.set('X-Robots-Tag', 'index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1');
+        c.res.headers.set('Content-Security-Policy', isProd
+            ? `default-src 'self'; script-src 'self' 'nonce-${cspNonce}'; style-src 'self'; img-src 'self' data:; font-src 'self' data:; connect-src 'self'; object-src 'none'; base-uri 'self'; form-action 'self'; frame-ancestors 'none'`
+            : "default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval'; style-src 'self' 'unsafe-inline'; img-src 'self' data:; font-src 'self' data:; connect-src 'self' ws: wss:; object-src 'none'; base-uri 'self'; form-action 'self'; frame-ancestors 'none'");
+        if (isProd) {
+            c.res.headers.set('Strict-Transport-Security', 'max-age=31536000; includeSubDomains; preload');
+        }
+    });
+    // Favicon redirect
+    app.get('/favicon.ico', (c) => c.redirect('/favicon.svg', 302));
+    // Analytics
+    const analyticsHandler = async (request) => {
+        const startedAt = Date.now();
+        const entry = await loadEntry();
+        if (!entry.analytics) {
+            const response = new Response(JSON.stringify({ message: 'Not Found' }), {
+                headers: { 'Content-Type': 'application/json; charset=utf-8' },
+                status: 404,
+            });
+            logDevRequest('analytics', request, response.status, startedAt, isProd);
+            return response;
+        }
+        const response = await handleAnalyticsRequest(request, entry.analytics);
+        logDevRequest('analytics', request, response.status, startedAt, isProd);
+        return response;
+    };
+    app.options(DEFAULT_ANALYTICS_ENDPOINT, async (c) => analyticsHandler(c.req.raw));
+    app.post(DEFAULT_ANALYTICS_ENDPOINT, async (c) => analyticsHandler(c.req.raw));
+    // Robots.txt
+    app.get('/robots.txt', async (c) => {
+        const startedAt = Date.now();
+        const entry = await loadEntry();
+        const config = entry.robotsConfig ?? defaultRobotsConfig();
+        const body = renderRobotsTxt(config);
+        c.header('Content-Type', 'text/plain; charset=utf-8');
+        c.header('Cache-Control', 'public, max-age=3600');
+        logDevRequest('robots', c.req.raw, 200, startedAt, isProd);
+        return c.text(body);
+    });
+    // Sitemap
+    app.get('/sitemap.xml', async (c) => {
+        const startedAt = Date.now();
+        const entry = await loadEntry();
+        const entries = entry.getSitemapEntries ? await entry.getSitemapEntries() : [];
+        const items = entries.map((item) => {
+            const parts = [`    <loc>${escapeXml(item.loc)}</loc>`];
+            if (item.lastmod)
+                parts.push(`    <lastmod>${escapeXml(item.lastmod)}</lastmod>`);
+            if (item.changefreq)
+                parts.push(`    <changefreq>${escapeXml(item.changefreq)}</changefreq>`);
+            if (item.priority !== undefined)
+                parts.push(`    <priority>${item.priority}</priority>`);
+            return `  <url>\n${parts.join('\n')}\n  </url>`;
+        });
+        const xml = [
+            '<?xml version="1.0" encoding="UTF-8"?>',
+            '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
+            ...items,
+            '</urlset>',
+        ].join('\n');
+        c.header('Content-Type', 'application/xml; charset=utf-8');
+        c.header('Cache-Control', 'public, max-age=3600');
+        logDevRequest('sitemap', c.req.raw, 200, startedAt, isProd, { entries: entries.length });
+        return c.text(xml);
+    });
+    // Payload endpoint (client navigation)
+    app.get('/__vorzela/payload', async (c) => {
+        const startedAt = Date.now();
+        const navigationHeader = c.req.header('X-Vorzela-Navigation');
+        if (navigationHeader !== 'payload') {
+            logDevRequest('payload', c.req.raw, 403, startedAt, isProd, { reason: 'missing-navigation-header' });
+            return c.json({ message: 'Forbidden' }, 403);
+        }
+        if (isProd) {
+            const origin = c.req.header('Origin');
+            const referer = c.req.header('Referer');
+            const host = c.req.header('Host');
+            if (origin) {
+                try {
+                    const originHost = new URL(origin).host;
+                    if (host && originHost !== host) {
+                        logDevRequest('payload', c.req.raw, 403, startedAt, isProd, { reason: 'origin-mismatch' });
+                        return c.json({ message: 'Forbidden' }, 403);
+                    }
+                }
+                catch {
+                    logDevRequest('payload', c.req.raw, 403, startedAt, isProd, { reason: 'invalid-origin' });
+                    return c.json({ message: 'Forbidden' }, 403);
+                }
+            }
+            else if (referer) {
+                try {
+                    const refererHost = new URL(referer).host;
+                    if (host && refererHost !== host) {
+                        logDevRequest('payload', c.req.raw, 403, startedAt, isProd, { reason: 'referer-mismatch' });
+                        return c.json({ message: 'Forbidden' }, 403);
+                    }
+                }
+                catch {
+                    logDevRequest('payload', c.req.raw, 403, startedAt, isProd, { reason: 'invalid-referer' });
+                    return c.json({ message: 'Forbidden' }, 403);
+                }
+            }
+            else {
+                logDevRequest('payload', c.req.raw, 403, startedAt, isProd, { reason: 'missing-origin-and-referer' });
+                return c.json({ message: 'Forbidden' }, 403);
+            }
+        }
+        try {
+            const routePath = c.req.query('path') ?? '/';
+            const entry = await loadEntry();
+            const payload = await entry.renderPayload({
+                path: routePath,
+                request: c.req.raw,
+            });
+            c.header('Cache-Control', 'no-store, no-cache, must-revalidate, max-age=0, private');
+            c.header('Pragma', 'no-cache');
+            c.header('Expires', '0');
+            if (payload.responseHeaders) {
+                for (const [key, value] of payload.responseHeaders) {
+                    c.header(key, value, { append: true });
+                }
+            }
+            const { responseHeaders: _, ...jsonPayload } = payload;
+            logDevRequest('payload', c.req.raw, payload.status, startedAt, isProd, {
+                path: routePath,
+                status: payload.status,
+            });
+            return c.json(jsonPayload, { status: payload.status });
+        }
+        catch (error) {
+            if (isRedirect(error)) {
+                c.header('Cache-Control', 'no-store, no-cache, must-revalidate, max-age=0, private');
+                c.header('Pragma', 'no-cache');
+                c.header('Expires', '0');
+                logDevRequest('payload', c.req.raw, error.status, startedAt, isProd, {
+                    redirect: error.to,
+                });
+                return c.json({
+                    redirect: {
+                        replace: error.replace,
+                        status: error.status,
+                        to: error.to,
+                    },
+                }, { status: error.status });
+            }
+            if (!isProd && vite) {
+                vite.ssrFixStacktrace(error);
+            }
+            logDevError('payload', error, isProd, {
+                path: c.req.query('path') ?? '/',
+            });
+            console.error(error);
+            c.header('Cache-Control', 'no-store, no-cache, must-revalidate, max-age=0, private');
+            c.header('Pragma', 'no-cache');
+            c.header('Expires', '0');
+            logDevRequest('payload', c.req.raw, 500, startedAt, isProd);
+            return c.json({ message: 'Internal Server Error' }, 500);
+        }
+    });
+    // Document SSR (catch-all)
+    app.get('*', async (c) => {
+        const startedAt = Date.now();
+        try {
+            const entry = await loadEntry();
+            const response = await entry.renderDocument({
+                request: c.req.raw,
+                assets,
+                nonce: c.get('cspNonce'),
+            });
+            logDevRequest('document', c.req.raw, response.status, startedAt, isProd);
+            return response;
+        }
+        catch (error) {
+            if (isRedirect(error)) {
+                logDevRequest('document', c.req.raw, error.status, startedAt, isProd, { redirect: error.to });
+                return c.redirect(error.to, error.status);
+            }
+            if (!isProd && vite) {
+                vite.ssrFixStacktrace(error);
+            }
+            logDevError('document', error, isProd, {
+                path: new URL(c.req.raw.url).pathname,
+            });
+            console.error(error);
+            logDevRequest('document', c.req.raw, 500, startedAt, isProd);
+            return c.text('Internal Server Error', 500);
+        }
+    });
+    return app;
+}

package/dist/session.d.ts

@@ -0,0 +1,23 @@
+import type { CookieOptions, VorzelaCookie } from './cookie';
+export interface SessionData {
+    [key: string]: unknown;
+}
+export interface VorzelaSession {
+    data: SessionData;
+    get<T = unknown>(key: string): T | undefined;
+    has(key: string): boolean;
+    set(key: string, value: unknown): void;
+    unset(key: string): void;
+    flash(key: string, value: unknown): void;
+}
+export interface SessionStorage {
+    commitSession(session: VorzelaSession): Promise<string>;
+    destroySession(session: VorzelaSession): Promise<string>;
+    getSession(cookieHeader: string | null): Promise<VorzelaSession>;
+}
+export declare function createCookieSessionStorage(options?: {
+    cookie?: VorzelaCookie | (CookieOptions & {
+        name?: string;
+    });
+}): SessionStorage;
+//# sourceMappingURL=session.d.ts.map

package/dist/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../src/session.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAG5D,MAAM,WAAW,WAAW;IAC1B,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CACvB;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,WAAW,CAAA;IACjB,GAAG,CAAC,CAAC,GAAG,OAAO,EAAE,GAAG,EAAE,MAAM,GAAG,CAAC,GAAG,SAAS,CAAA;IAC5C,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;IACzB,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAAA;IACtC,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,IAAI,CAAA;CACzC;AAED,MAAM,WAAW,cAAc;IAC7B,aAAa,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IACvD,cAAc,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IACxD,UAAU,CAAC,YAAY,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,cAAc,CAAC,CAAA;CACjE;AA0CD,wBAAgB,0BAA0B,CAAC,OAAO,GAAE;IAClD,MAAM,CAAC,EAAE,aAAa,GAAG,CAAC,aAAa,GAAG;QAAE,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CACxD,GAAG,cAAc,CAiCtB"}

package/dist/session.js

@@ -0,0 +1,58 @@
+import { createCookie } from './cookie';
+const FLASH_PREFIX = '__flash_';
+function createSession(data = {}) {
+    const sessionData = { ...data };
+    return {
+        get data() {
+            return { ...sessionData };
+        },
+        get(key) {
+            const flashKey = `${FLASH_PREFIX}${key}`;
+            if (flashKey in sessionData) {
+                const value = sessionData[flashKey];
+                delete sessionData[flashKey];
+                return value;
+            }
+            return sessionData[key];
+        },
+        has(key) {
+            return key in sessionData || `${FLASH_PREFIX}${key}` in sessionData;
+        },
+        set(key, value) {
+            sessionData[key] = value;
+        },
+        unset(key) {
+            delete sessionData[key];
+        },
+        flash(key, value) {
+            sessionData[`${FLASH_PREFIX}${key}`] = value;
+        },
+    };
+}
+export function createCookieSessionStorage(options = {}) {
+    const cookie = options.cookie && 'parse' in options.cookie
+        ? options.cookie
+        : createCookie(options.cookie?.name ?? '__session', options.cookie ?? {});
+    return {
+        async getSession(cookieHeader) {
+            const raw = await cookie.parse(cookieHeader);
+            if (!raw) {
+                return createSession();
+            }
+            try {
+                const data = JSON.parse(raw);
+                return createSession(data);
+            }
+            catch {
+                return createSession();
+            }
+        },
+        async commitSession(session) {
+            const serialized = JSON.stringify(session.data);
+            return cookie.serialize(serialized);
+        },
+        async destroySession(_session) {
+            return cookie.destroy();
+        },
+    };
+}

package/dist/vite/index.d.ts

@@ -0,0 +1,13 @@
+import type { Plugin, UserConfig } from 'vite';
+export interface VorzelaPluginOptions {
+    /** Override the Solid plugin. Pass `false` to disable auto-detection. */
+    solid?: false | Plugin;
+    /** Override the Tailwind plugin. Pass `false` to disable auto-detection. */
+    tailwind?: false | Plugin;
+}
+export declare function vorzelaPlugin(options?: VorzelaPluginOptions): Plugin[];
+export declare function resolveVorzelaConfig(appRoot: string, options?: VorzelaPluginOptions): Promise<UserConfig>;
+export declare function resolveVorzelalBuildConfig(appRoot: string, mode: 'client' | 'server'): UserConfig;
+export { generateRoutes, vorzelaRoutesPlugin } from './routes-plugin';
+export { vorzelaServerOnlyPlugin } from './server-only';
+//# sourceMappingURL=index.d.ts.map

package/dist/vite/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/vite/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,MAAM,CAAA;AAiB9C,MAAM,WAAW,oBAAoB;IACnC,yEAAyE;IACzE,KAAK,CAAC,EAAE,KAAK,GAAG,MAAM,CAAA;IACtB,4EAA4E;IAC5E,QAAQ,CAAC,EAAE,KAAK,GAAG,MAAM,CAAA;CAC1B;AAoFD,wBAAgB,aAAa,CAAC,OAAO,GAAE,oBAAyB,GAAG,MAAM,EAAE,CAO1E;AAED,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,MAAM,EACf,OAAO,GAAE,oBAAyB,GACjC,OAAO,CAAC,UAAU,CAAC,CAoCrB;AAED,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,QAAQ,GAAG,QAAQ,GACxB,UAAU,CAqCZ;AAED,OAAO,EAAE,cAAc,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAA;AACrE,OAAO,EAAE,uBAAuB,EAAE,MAAM,eAAe,CAAA"}

package/dist/vite/index.js

@@ -0,0 +1,174 @@
+import path from 'node:path';
+import url from 'node:url';
+import { vorzelaRoutesPlugin } from './routes-plugin';
+const VIRTUAL_ROUTES = 'virtual:vorzela/routes';
+const VIRTUAL_HYDRATION = 'virtual:vorzela/hydration';
+const VIRTUAL_STYLES = 'virtual:vorzela/styles';
+const VIRTUAL_ENTRY_CLIENT = 'virtual:vorzela/entry-client';
+const VIRTUAL_ENTRY_SERVER = 'virtual:vorzela/entry-server';
+const RESOLVED_VIRTUAL_ROUTES = `\0${VIRTUAL_ROUTES}`;
+const RESOLVED_VIRTUAL_HYDRATION = `\0${VIRTUAL_HYDRATION}`;
+const RESOLVED_VIRTUAL_STYLES = `\0${VIRTUAL_STYLES}`;
+const RESOLVED_VIRTUAL_ENTRY_CLIENT = `\0${VIRTUAL_ENTRY_CLIENT}`;
+const RESOLVED_VIRTUAL_ENTRY_SERVER = `\0${VIRTUAL_ENTRY_SERVER}`;
+function resolveFrameworkDir() {
+    const thisFile = url.fileURLToPath(import.meta.url);
+    // In built form: dist/vite/index.js -> dist/
+    // In source form: src/vite/index.ts -> src/
+    return path.resolve(path.dirname(thisFile), '..');
+}
+function tryRequirePlugin(name) {
+    try {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const mod = require(name);
+        return typeof mod === 'function' ? mod() : typeof mod.default === 'function' ? mod.default() : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function tryImportPlugin(name) {
+    try {
+        const mod = await import(name);
+        const fn = mod.default ?? mod;
+        return typeof fn === 'function' ? fn() : null;
+    }
+    catch {
+        return null;
+    }
+}
+function vorzelaVirtualModulesPlugin() {
+    let appRoot = process.cwd();
+    let frameworkDir = resolveFrameworkDir();
+    return {
+        name: 'vorzelajs-virtual-modules',
+        enforce: 'pre',
+        configResolved(config) {
+            appRoot = config.root;
+        },
+        resolveId(id) {
+            switch (id) {
+                case VIRTUAL_ROUTES:
+                    return RESOLVED_VIRTUAL_ROUTES;
+                case VIRTUAL_HYDRATION:
+                    return RESOLVED_VIRTUAL_HYDRATION;
+                case VIRTUAL_STYLES:
+                    return RESOLVED_VIRTUAL_STYLES;
+                case VIRTUAL_ENTRY_CLIENT:
+                    return RESOLVED_VIRTUAL_ENTRY_CLIENT;
+                case VIRTUAL_ENTRY_SERVER:
+                    return RESOLVED_VIRTUAL_ENTRY_SERVER;
+                default:
+                    return null;
+            }
+        },
+        load(id) {
+            switch (id) {
+                case RESOLVED_VIRTUAL_ROUTES: {
+                    const routeTreePath = path.resolve(appRoot, 'src/routeTree.gen.ts');
+                    return `export * from ${JSON.stringify(routeTreePath)}`;
+                }
+                case RESOLVED_VIRTUAL_HYDRATION: {
+                    const hydrationPath = path.resolve(appRoot, 'src/routeHydration.gen.ts');
+                    return `export * from ${JSON.stringify(hydrationPath)}`;
+                }
+                case RESOLVED_VIRTUAL_STYLES: {
+                    const stylesPath = path.resolve(appRoot, 'src/styles.css');
+                    return `import ${JSON.stringify(stylesPath)}`;
+                }
+                case RESOLVED_VIRTUAL_ENTRY_CLIENT: {
+                    const entryPath = path.resolve(frameworkDir, 'internal/entry-client.tsx');
+                    return `export * from ${JSON.stringify(entryPath)}`;
+                }
+                case RESOLVED_VIRTUAL_ENTRY_SERVER: {
+                    const entryPath = path.resolve(frameworkDir, 'internal/entry-server.tsx');
+                    return `export * from ${JSON.stringify(entryPath)}`;
+                }
+                default:
+                    return null;
+            }
+        },
+    };
+}
+export function vorzelaPlugin(options = {}) {
+    const plugins = [
+        vorzelaVirtualModulesPlugin(),
+        vorzelaRoutesPlugin(),
+    ];
+    return plugins;
+}
+export async function resolveVorzelaConfig(appRoot, options = {}) {
+    const plugins = [...vorzelaPlugin(options)];
+    // Auto-detect Solid plugin
+    if (options.solid !== false) {
+        if (options.solid) {
+            plugins.push(options.solid);
+        }
+        else {
+            const solidPlugin = await tryImportPlugin('vite-plugin-solid');
+            if (solidPlugin) {
+                plugins.push(solidPlugin);
+            }
+        }
+    }
+    // Auto-detect Tailwind plugin
+    if (options.tailwind !== false) {
+        if (options.tailwind) {
+            plugins.push(options.tailwind);
+        }
+        else {
+            const tailwindPlugin = await tryImportPlugin('@tailwindcss/vite');
+            if (tailwindPlugin) {
+                plugins.push(tailwindPlugin);
+            }
+        }
+    }
+    return {
+        root: appRoot,
+        resolve: {
+            alias: {
+                '~': path.resolve(appRoot, 'src'),
+            },
+        },
+        plugins,
+    };
+}
+export function resolveVorzelalBuildConfig(appRoot, mode) {
+    if (mode === 'server') {
+        return {
+            build: {
+                outDir: 'dist/server',
+                emptyOutDir: false,
+                copyPublicDir: false,
+                ssr: true,
+                rollupOptions: {
+                    input: VIRTUAL_ENTRY_SERVER,
+                    output: {
+                        entryFileNames: 'entry-server.js',
+                        chunkFileNames: 'chunks/[name]-[hash].js',
+                        assetFileNames: 'assets/[name]-[hash][extname]',
+                    },
+                },
+            },
+        };
+    }
+    return {
+        build: {
+            cssCodeSplit: false,
+            outDir: 'dist/client',
+            emptyOutDir: true,
+            copyPublicDir: true,
+            manifest: true,
+            rollupOptions: {
+                input: VIRTUAL_ENTRY_CLIENT,
+                output: {
+                    entryFileNames: 'assets/[name]-[hash].js',
+                    chunkFileNames: 'assets/[name]-[hash].js',
+                    assetFileNames: 'assets/[name]-[hash][extname]',
+                },
+            },
+        },
+    };
+}
+export { generateRoutes, vorzelaRoutesPlugin } from './routes-plugin';
+export { vorzelaServerOnlyPlugin } from './server-only';

package/dist/vite/routes-plugin.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from 'vite';
+export declare function generateRoutes(projectRoot?: string): Promise<void>;
+export declare function vorzelaRoutesPlugin(): Plugin;
+//# sourceMappingURL=routes-plugin.d.ts.map

package/dist/vite/routes-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes-plugin.d.ts","sourceRoot":"","sources":["../../src/vite/routes-plugin.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,MAAM,CAAA;AA+VlC,wBAAsB,cAAc,CAAC,WAAW,SAAgB,iBA2B/D;AAED,wBAAgB,mBAAmB,IAAI,MAAM,CA2C5C"}