@ressjs/vite-router 0.3.0 → 0.4.1

package/dist/index.js

@@ -1,6 +1,21 @@
-// Main API - Versión simplificada que funciona con el servidor existente
-export { createViteRouter, createAutoViteServer, detectPlatform, listDetectedPages, getPages } from './simple-router.js';
-// Legacy exports para compatibilidad (deprecated)
-export { RouterFactory, createInitializedViteRouter } from './router-factory.js';
-export { PageDetector } from './page-detector.js';
-export { EntryGenerator } from './entry-generator.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveEntryClient = exports.getPlatformCSSClass = exports.detectPlatform = exports.resolvePlatformCSS = exports.createRenderServer = exports.generateTempEntries = exports.getClientEntriesInput = exports.getViteInput = exports.getPages = exports.listDetectedPages = exports.createAutoViteServer = exports.createViteRouter = void 0;
+// Main API
+var router_1 = require("./router");
+Object.defineProperty(exports, "createViteRouter", { enumerable: true, get: function () { return router_1.createViteRouter; } });
+Object.defineProperty(exports, "createAutoViteServer", { enumerable: true, get: function () { return router_1.createAutoViteServer; } });
+Object.defineProperty(exports, "listDetectedPages", { enumerable: true, get: function () { return router_1.listDetectedPages; } });
+Object.defineProperty(exports, "getPages", { enumerable: true, get: function () { return router_1.getPages; } });
+// Core functions for Vite config
+var pages_1 = require("./pages");
+Object.defineProperty(exports, "getViteInput", { enumerable: true, get: function () { return pages_1.getViteInput; } });
+Object.defineProperty(exports, "getClientEntriesInput", { enumerable: true, get: function () { return pages_1.getClientEntriesInput; } });
+Object.defineProperty(exports, "generateTempEntries", { enumerable: true, get: function () { return pages_1.generateTempEntries; } });
+Object.defineProperty(exports, "createRenderServer", { enumerable: true, get: function () { return pages_1.createRenderServer; } });
+Object.defineProperty(exports, "resolvePlatformCSS", { enumerable: true, get: function () { return pages_1.resolvePlatformCSS; } });
+// Platform detection
+var platform_1 = require("./platform");
+Object.defineProperty(exports, "detectPlatform", { enumerable: true, get: function () { return platform_1.detectPlatform; } });
+Object.defineProperty(exports, "getPlatformCSSClass", { enumerable: true, get: function () { return platform_1.getPlatformCSSClass; } });
+Object.defineProperty(exports, "resolveEntryClient", { enumerable: true, get: function () { return platform_1.resolveEntryClient; } });

package/dist/pages.d.ts

@@ -0,0 +1,26 @@
+import type { PlatformInfo } from './platform';
+export interface PageInfo {
+    route: string;
+    file: string;
+    abs: string;
+}
+export declare function getPages(): PageInfo[];
+export declare function getViteInput(): Record<string, string>;
+export declare function loadManifest(distPath?: string): Promise<any>;
+export declare function resolvePlatformCSS(basePath: string, platform: PlatformInfo): Promise<string>;
+export declare function generateTempEntries(distPath?: string, platformInfo?: PlatformInfo): Promise<string[]>;
+export declare function generateSingleEntry(page: PageInfo, entryPath: string, preferredScssFile: string): Promise<void>;
+export declare function getClientEntriesInput(distPath?: string): Promise<Record<string, string>>;
+export interface RenderOptions {
+    url: string;
+    props?: any;
+}
+export interface CreateRenderServerOptions {
+    vite?: any;
+}
+export declare function createRenderServer(options?: CreateRenderServerOptions): (renderOptions: RenderOptions) => Promise<{
+    html: string;
+    props: any;
+    route: string;
+    page: string;
+}>;

package/dist/pages.js

@@ -0,0 +1,296 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPages = getPages;
+exports.getViteInput = getViteInput;
+exports.loadManifest = loadManifest;
+exports.resolvePlatformCSS = resolvePlatformCSS;
+exports.generateTempEntries = generateTempEntries;
+exports.generateSingleEntry = generateSingleEntry;
+exports.getClientEntriesInput = getClientEntriesInput;
+exports.createRenderServer = createRenderServer;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const react_1 = __importDefault(require("react"));
+const server_1 = require("react-dom/server");
+function getPages() {
+    // Busca tanto page.tsx como page/index.tsx y prioriza el más corto
+    const files = fast_glob_1.default.sync('app/pages/**/*.{tsx,jsx}');
+    const seen = new Set();
+    const pages = [];
+    for (const file of files) {
+        let route = file.replace(/^app\/pages/, '').replace(/\.tsx$|\.jsx$/, '');
+        route = route.replace(/\/index$/, '') || '/';
+        // Prioriza page.tsx sobre page/index.tsx
+        if (!seen.has(route)) {
+            seen.add(route);
+            pages.push({ route, file, abs: node_path_1.default.resolve(file) });
+        }
+    }
+    return pages;
+}
+// Para Vite: input { [route]: absPath }
+function getViteInput() {
+    const pages = getPages();
+    const input = {};
+    for (const page of pages) {
+        input[page.file.replace(/^app\/pages\//, '').replace(/\.tsx$|\.jsx$/, '')] = page.abs;
+    }
+    return input;
+}
+async function loadManifest(distPath = 'dist') {
+    const assetsDir = node_path_1.default.join(distPath, 'server/.vite');
+    const files = await promises_1.default.readdir(assetsDir);
+    const manifestFile = files.find(f => /^manifest-.*\.js$/.test(f));
+    if (!manifestFile)
+        throw new Error('No manifest file found in dist/server/assets');
+    // Import dinámico del manifest
+    const manifest = (await Promise.resolve(`${node_path_1.default.join(assetsDir, manifestFile)}`).then(s => __importStar(require(s)))).default;
+    return manifest;
+}
+async function fileExists(file) {
+    try {
+        await promises_1.default.access(file);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Platform-aware CSS resolution
+ * Busca CSS files con prioridades basadas en platform detection
+ */
+// Función helper para determinar si es probablemente un dispositivo móvil
+function isProbablyMobile(platform) {
+    // Mobile si es phone/tablet, o webview (que suele ser mobile), o category native (React Native)
+    return platform.device === 'phone' ||
+        platform.device === 'tablet' ||
+        platform.category === 'webview' ||
+        platform.category === 'native';
+}
+async function resolvePlatformCSS(basePath, platform) {
+    // Orden de prioridad corregido: OS first → device+OS → device → mobile condicional
+    const priorities = [];
+    // 1. OS específico primero: android.scss, ios.scss
+    priorities.push(`${basePath}.${platform.os}.scss`);
+    // Para webview, agregar combinaciones específicas después del OS
+    if (platform.category === 'webview') {
+        // 2. webview.os.scss (ej: webview.android.scss, webview.ios.scss)  
+        priorities.push(`${basePath}.webview.${platform.os}.scss`);
+        // 3. webview.scss general
+        priorities.push(`${basePath}.webview.scss`);
+    }
+    // Para native o web, agregar combinaciones device.os
+    if (platform.category === 'native' || platform.category === 'web') {
+        // 2. device.os.scss (ej: phone.android.scss, tablet.ios.scss)
+        priorities.push(`${basePath}.${platform.device}.${platform.os}.scss`);
+    }
+    // 3. Device específico: phone.scss, tablet.scss, desktop.scss
+    priorities.push(`${basePath}.${platform.device}.scss`);
+    // 4. Mobile fallback SOLO si es probablemente móvil
+    if (isProbablyMobile(platform)) {
+        priorities.push(`${basePath}.mobile.scss`);
+    }
+    // 5. Fallback final
+    priorities.push(`${basePath}.scss`);
+    // Retorna el primer archivo que exista
+    for (const file of priorities) {
+        if (await fileExists(file)) {
+            return file;
+        }
+    }
+    // Si ninguno existe, retorna el CSS base
+    return `${basePath}.scss`;
+}
+async function generateTempEntries(distPath = 'dist', platformInfo) {
+    const pages = getPages();
+    const entriesDir = node_path_1.default.resolve(distPath, '.entries');
+    // Solo crea el directorio si no existe, no lo borra
+    await promises_1.default.mkdir(entriesDir, { recursive: true });
+    const promises = pages.map(async (page) => {
+        const rel = page.file.replace(/^app\/pages\//, '').replace(/\.tsx$|\.jsx$/, '').replace(/\//g, '__');
+        if (platformInfo && platformInfo.device !== 'desktop') {
+            // Solo genera entry específico para mobile devices (phone, tablet)
+            const basePath = page.file.replace(/\.(tsx|jsx)$/, '');
+            const platformCSS = await resolvePlatformCSS(basePath, platformInfo);
+            // Generar entry específico con el CSS resuelto (puede ser base o específico)
+            const platformSuffix = `${platformInfo.device}.${platformInfo.os}`;
+            const entryPath = node_path_1.default.join(entriesDir, rel + `__entry-client.${platformSuffix}.tsx`);
+            await generateSingleEntry(page, entryPath, platformCSS);
+            return [entryPath];
+        }
+        else {
+            // Lógica mejorada: busca dinámicamente todos los archivos CSS específicos
+            const basePath = page.file.replace(/\.(tsx|jsx)$/, '');
+            const baseScss = basePath + '.scss';
+            const results = [];
+            // Genera entry-client base (desktop) - solo CSS base
+            const entryPath = node_path_1.default.join(entriesDir, rel + '__entry-client.tsx');
+            await generateSingleEntry(page, entryPath, baseScss);
+            results.push(entryPath);
+            // Buscar dinámicamente todos los archivos CSS específicos de plataforma
+            const glob = await Promise.resolve().then(() => __importStar(require('fast-glob')));
+            const cssFiles = await glob.default(`${basePath}.*.scss`);
+            for (const cssFile of cssFiles) {
+                // Extraer el sufijo del archivo CSS (ej: mobile, webview.android, desktop.linux)
+                const suffix = cssFile
+                    .replace(basePath + '.', '')
+                    .replace('.scss', '');
+                // Generar entry-client específico
+                const specificEntryPath = node_path_1.default.join(entriesDir, rel + `__entry-client.${suffix}.tsx`);
+                await generateSingleEntry(page, specificEntryPath, cssFile);
+                results.push(specificEntryPath);
+            }
+            return results;
+        }
+    });
+    const entryFiles = await Promise.all(promises);
+    return entryFiles.flat().filter(Boolean);
+}
+async function generateSingleEntry(page, entryPath, preferredScssFile) {
+    // Verifica si el archivo ya existe y es más reciente que el archivo fuente
+    try {
+        const entryStat = await promises_1.default.stat(entryPath);
+        const pageStat = await promises_1.default.stat(page.abs);
+        if (entryStat.mtime > pageStat.mtime) {
+            return; // El entry ya existe y está actualizado
+        }
+    }
+    catch {
+        // El archivo no existe, continúa con la generación
+    }
+    const importPath = node_path_1.default.relative(node_path_1.default.dirname(entryPath), page.abs).replace(/\\/g, '/');
+    // Lógica de fallback: intenta cargar el CSS preferido, si no existe carga el base
+    let scssToImport = '';
+    let scssImport = '';
+    if (await fileExists(preferredScssFile)) {
+        // Existe el CSS específico, usarlo
+        scssToImport = preferredScssFile;
+    }
+    else {
+        // No existe el CSS específico, usar el CSS base como fallback
+        const baseScss = page.file.replace(/\.(tsx|jsx)$/, '.scss');
+        if (await fileExists(baseScss)) {
+            scssToImport = baseScss;
+        }
+    }
+    if (scssToImport) {
+        const scssImportPath = node_path_1.default.relative(node_path_1.default.dirname(entryPath), scssToImport).replace(/\\/g, '/');
+        scssImport = `import "${scssImportPath.startsWith('.') ? scssImportPath : './' + scssImportPath}";`;
+    }
+    const template = `
+${scssImport}
+import { StrictMode } from "react";
+import { hydrateRoot } from "react-dom/client";
+import Page from "${importPath.startsWith('.') ? importPath : './' + importPath}";
+const props = window.__INITIAL_PROPS__ || {};
+hydrateRoot(document.getElementById("root"), <StrictMode><Page {...props} /></StrictMode>);
+`.trim();
+    await promises_1.default.mkdir(node_path_1.default.dirname(entryPath), { recursive: true });
+    await promises_1.default.writeFile(entryPath, template);
+}
+async function getClientEntriesInput(distPath = 'dist') {
+    await generateTempEntries(distPath);
+    // Incluir todos los entry-clients: base, mobile, desktop.linux
+    const entryFiles = fast_glob_1.default.sync(`${distPath}/.entries/**/*__entry-client*.tsx`);
+    const input = {};
+    for (const file of entryFiles) {
+        // Mantener el nombre completo del archivo como key para diferenciar las plataformas
+        const key = file.replace(new RegExp(`^${distPath}/\\.entries/`), '');
+        input[key] = node_path_1.default.resolve(file);
+    }
+    return input;
+}
+function createRenderServer(options = {}) {
+    const pages = getPages();
+    const { vite } = options;
+    return async (renderOptions) => {
+        const { url, props = {} } = renderOptions;
+        // Encuentra la página que coincide con la URL
+        const matchedPage = pages.find(page => {
+            if (page.route === '/')
+                return url === '/' || url === '';
+            return url === page.route || url.startsWith(page.route + '/');
+        });
+        if (!matchedPage) {
+            throw new Error(`Page not found for URL: ${url}`);
+        }
+        try {
+            // Import dinámico de la página usando vite.ssrLoadModule si está disponible
+            let pageModule;
+            if (vite) {
+                // En desarrollo: usar vite.ssrLoadModule para manejar .tsx
+                const modulePath = `/${matchedPage.file}`;
+                pageModule = await vite.ssrLoadModule(modulePath);
+            }
+            else {
+                // En producción: usar import directo del archivo compilado
+                const moduleUrl = matchedPage.abs.replace(/\.tsx$/, '.js').replace('/app/pages/', '/dist/server/');
+                pageModule = await Promise.resolve(`${moduleUrl}`).then(s => __importStar(require(s)));
+            }
+            const PageComponent = pageModule.default;
+            const getServerSideProps = pageModule.getServerSideProps;
+            if (!PageComponent) {
+                throw new Error(`No default export found in ${matchedPage.file}`);
+            }
+            // Si existe getServerSideProps, la ejecutamos para obtener props iniciales
+            let finalProps = { ...props };
+            if (getServerSideProps && typeof getServerSideProps === 'function') {
+                console.log(`Calling getServerSideProps for ${matchedPage.route}`);
+                const serverSideResult = await getServerSideProps();
+                if (serverSideResult && serverSideResult.props) {
+                    finalProps = { ...finalProps, ...serverSideResult.props };
+                }
+            }
+            // Renderiza el componente con las props finales
+            const html = (0, server_1.renderToString)(react_1.default.createElement(PageComponent, finalProps));
+            return {
+                html,
+                props: finalProps,
+                route: matchedPage.route,
+                page: matchedPage.file
+            };
+        }
+        catch (error) {
+            console.error(`Error rendering page ${matchedPage.route}:`, error);
+            throw error;
+        }
+    };
+}

package/dist/platform.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Platform detection for ress.js
+ * Combina headers custom de React Native con User-Agent parsing
+ */
+export interface PlatformInfo {
+    category: 'web' | 'webview' | 'native';
+    os: 'ios' | 'android' | 'windows' | 'macos' | 'linux' | 'unknown';
+    device: 'phone' | 'tablet' | 'desktop';
+    version?: string;
+    appVersion?: string;
+    source: 'headers' | 'user-agent';
+}
+/**
+ * Detecta plataforma usando headers custom + User-Agent fallback
+ */
+export declare function detectPlatform(userAgent: string, headers?: any): PlatformInfo;
+/**
+ * Genera CSS class para HTML basado en platform info
+ */
+export declare function getPlatformCSSClass(platform: PlatformInfo): string;
+/**
+ * Determina qué entry-client usar basado en platform
+ */
+export declare function resolveEntryClient(baseName: string, platform: PlatformInfo): string;

package/dist/platform.js

@@ -0,0 +1,143 @@
+"use strict";
+/**
+ * Platform detection for ress.js
+ * Combina headers custom de React Native con User-Agent parsing
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectPlatform = detectPlatform;
+exports.getPlatformCSSClass = getPlatformCSSClass;
+exports.resolveEntryClient = resolveEntryClient;
+/**
+ * Detecta plataforma usando headers custom + User-Agent fallback
+ */
+function detectPlatform(userAgent, headers = {}) {
+    const ressHeaders = headers;
+    // 1. React Native headers detection
+    if (ressHeaders['x-rn-platform']) {
+        return {
+            category: 'native',
+            os: ressHeaders['x-rn-platform'] || 'android',
+            device: 'phone', // React Native es típicamente mobile
+            version: ressHeaders['x-rn-version'],
+            source: 'headers'
+        };
+    }
+    // 2. WebView headers detection
+    if (ressHeaders['x-webview'] === 'true' || ressHeaders['x-ressjs-platform'] === 'webview') {
+        const os = ressHeaders['x-platform'] || ressHeaders['x-ressjs-os'] || 'android';
+        return {
+            category: 'webview',
+            os: os,
+            device: ressHeaders['x-ressjs-device'] || 'phone',
+            version: ressHeaders['x-ressjs-version'],
+            appVersion: ressHeaders['x-ressjs-app-version'],
+            source: 'headers'
+        };
+    }
+    // 3. Ress.js specific headers (original logic)
+    if (ressHeaders['x-ressjs-platform'] === 'webview') {
+        return {
+            category: 'webview',
+            os: ressHeaders['x-ressjs-os'] || 'android',
+            device: ressHeaders['x-ressjs-device'] || 'phone',
+            version: ressHeaders['x-ressjs-version'],
+            appVersion: ressHeaders['x-ressjs-app-version'],
+            source: 'headers'
+        };
+    }
+    // 4. User-Agent fallback detection
+    return detectFromUserAgent(userAgent);
+}
+/**
+ * Detección por User-Agent (navegadores estándar)
+ */
+function detectFromUserAgent(userAgent) {
+    const ua = userAgent.toLowerCase();
+    // SPECIAL CASE: React Native
+    if (ua.includes('reactnative')) {
+        let os = 'android';
+        if (ua.includes('ios')) {
+            os = 'ios';
+        }
+        else if (ua.includes('android')) {
+            os = 'android';
+        }
+        return {
+            category: 'native',
+            os,
+            device: 'phone', // React Native siempre mobile
+            source: 'user-agent'
+        };
+    }
+    // Detectar OS
+    let os = 'unknown';
+    if (ua.includes('iphone') || ua.includes('ipad') || ua.includes('ios')) {
+        os = 'ios';
+    }
+    else if (ua.includes('android')) {
+        os = 'android';
+    }
+    else if (ua.includes('windows')) {
+        os = 'windows';
+    }
+    else if (ua.includes('macintosh') || ua.includes('mac os x')) {
+        os = 'macos';
+    }
+    else if (ua.includes('linux')) {
+        os = 'linux';
+    }
+    // Detectar device type
+    let device = 'desktop';
+    if (ua.includes('ipad')) {
+        device = 'tablet';
+    }
+    else if (ua.includes('mobile') || ua.includes('phone')) {
+        device = 'phone';
+    }
+    else if (ua.includes('tablet')) {
+        device = 'tablet';
+    }
+    // Detectar category (web vs webview)
+    let category = 'web';
+    return {
+        category,
+        os,
+        device,
+        source: 'user-agent'
+    };
+}
+/**
+ * Genera CSS class para HTML basado en platform info
+ */
+function getPlatformCSSClass(platform) {
+    const classes = [
+        platform.category, // 'web', 'webview', 'native'
+        platform.device, // 'phone', 'tablet', 'desktop'
+        platform.os // 'ios', 'android', etc.
+    ];
+    return classes.join(' ');
+}
+/**
+ * Determina qué entry-client usar basado en platform
+ */
+function resolveEntryClient(baseName, platform) {
+    const candidates = [
+        // Específico para mobile: device.os (phone.ios, tablet.android)
+        ...(platform.device !== 'desktop'
+            ? [`${baseName}__entry-client.${platform.device}.${platform.os}.tsx`]
+            : []),
+        // OS específico: ios, android
+        `${baseName}__entry-client.${platform.os}.tsx`,
+        // Device: mobile, desktop, tablet
+        `${baseName}__entry-client.${platform.device}.tsx`,
+        // Legacy compatibility
+        ...(platform.device === 'phone' || platform.device === 'tablet'
+            ? [`${baseName}__entry-client.mobile.tsx`]
+            : []),
+        // Fallback
+        `${baseName}__entry-client.tsx`
+    ];
+    // En producción, deberías verificar que el archivo existe
+    // Por ahora retorna el primer candidato
+    return candidates[0];
+}

package/dist/render.d.ts

@@ -0,0 +1,13 @@
+export interface RenderOptions {
+    url: string;
+    props?: any;
+}
+export interface CreateRenderServerOptions {
+    vite?: any;
+}
+export declare function createRenderServer(options?: CreateRenderServerOptions): (renderOptions: RenderOptions) => Promise<{
+    html: string;
+    props: any;
+    route: string;
+    page: string;
+}>;

package/dist/render.js

@@ -0,0 +1,98 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRenderServer = createRenderServer;
+const react_1 = __importDefault(require("react"));
+const server_1 = require("react-dom/server");
+const pages_1 = require("./pages");
+function createRenderServer(options = {}) {
+    const pages = (0, pages_1.getPages)();
+    const { vite } = options;
+    return async (renderOptions) => {
+        const { url, props = {} } = renderOptions;
+        // Encuentra la página que coincide con la URL
+        const matchedPage = pages.find(page => {
+            if (page.route === '/')
+                return url === '/' || url === '';
+            return url === page.route || url.startsWith(page.route + '/');
+        });
+        if (!matchedPage) {
+            throw new Error(`Page not found for URL: ${url}`);
+        }
+        try {
+            // Import dinámico de la página usando vite.ssrLoadModule si está disponible
+            let pageModule;
+            if (vite) {
+                // En desarrollo: usar vite.ssrLoadModule para manejar .tsx
+                const modulePath = `/${matchedPage.file}`;
+                pageModule = await vite.ssrLoadModule(modulePath);
+            }
+            else {
+                // En producción: usar import directo del archivo compilado
+                const moduleUrl = matchedPage.abs.replace(/\.tsx$/, '.js').replace('/app/pages/', '/dist/server/');
+                pageModule = await Promise.resolve(`${moduleUrl}`).then(s => __importStar(require(s)));
+            }
+            const PageComponent = pageModule.default;
+            const getServerSideProps = pageModule.getServerSideProps;
+            if (!PageComponent) {
+                throw new Error(`No default export found in ${matchedPage.file}`);
+            }
+            // Si existe getServerSideProps, la ejecutamos para obtener props iniciales
+            let finalProps = { ...props };
+            if (getServerSideProps && typeof getServerSideProps === 'function') {
+                console.log(`Calling getServerSideProps for ${matchedPage.route}`);
+                const serverSideResult = await getServerSideProps();
+                if (serverSideResult && serverSideResult.props) {
+                    finalProps = { ...finalProps, ...serverSideResult.props };
+                }
+            }
+            // Renderiza el componente con las props finales
+            const html = (0, server_1.renderToString)(react_1.default.createElement(PageComponent, finalProps));
+            return {
+                html,
+                props: finalProps,
+                route: matchedPage.route,
+                page: matchedPage.file
+            };
+        }
+        catch (error) {
+            console.error(`Error rendering page ${matchedPage.route}:`, error);
+            throw error;
+        }
+    };
+}

package/dist/{simple-router.d.ts → router.d.ts}

@@ -1,10 +1,11 @@
 import { Router } from 'express';
 export interface ViteRouterOptions {
     enablePlatformDetection?: boolean;
+    isProduction?: boolean;
+    pagesDirectory?: string;
+    basePath?: string;
     vite?: any;
-    manifest?: any;
     templateHtml?: string;
-    isProduction?: boolean;
     renderFunction?: (options: {
         url: string;
         platform: string;
@@ -16,28 +17,11 @@ export interface AutoViteServerOptions {
     base?: string;
     enablePlatformDetection?: boolean;
 }
-/**
- * Crea un servidor Express completo con vite-router automático
- * Esta es la función de alto nivel para casos simples
- */
 export declare function createAutoViteServer(options?: AutoViteServerOptions): Promise<{
     app: import("express-serve-static-core").Express;
     vite: any;
     start: () => import("http").Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse>;
 }>;
-/**
- * Crea un Express router que automáticamente detecta páginas, las rutea,
- * y maneja todo el SSR + hidratación del cliente.
- *
- * Si no se pasan opciones, auto-configura Vite, manifest, templates, etc.
- */
 export declare function createViteRouter(options?: ViteRouterOptions): Router;
-/**
- * Detecta platform desde el User-Agent
- */
-export declare function detectPlatform(userAgent: string): 'desktop' | 'mobile';
-/**
- * Helper para listar páginas detectadas
- */
-export declare function listDetectedPages(): import("@ressjs/core").PageInfo[];
-export { getPages } from '@ressjs/core';
+export declare function listDetectedPages(): import("./pages").PageInfo[];
+export { getPages } from './pages';