hightjs 0.2.42 → 0.2.45

package/dist/auth/providers/google.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GoogleProvider = void 0;
+const http_1 = require("../../api/http");
+/**
+ * Provider para autenticação com Google OAuth2
+ *
+ * Este provider permite autenticação usando Google OAuth2.
+ * Automaticamente gerencia o fluxo OAuth completo e rotas necessárias.
+ *
+ * Exemplo de uso:
+ * ```typescript
+ * new GoogleProvider({
+ * clientId: process.env.GOOGLE_CLIENT_ID!,
+ * clientSecret: process.env.GOOGLE_CLIENT_SECRET!,
+ * callbackUrl: "http://localhost:3000/api/auth/callback/google"
+ * })
+ * ```
+ *
+ * Fluxo de autenticação:
+ * 1. GET /api/auth/signin/google - Gera URL e redireciona para Google
+ * 2. Google redireciona para /api/auth/callback/google com código
+ * 3. Provider troca código por token e busca dados do usuário
+ * 4. Retorna objeto User com dados do Google
+ */
+class GoogleProvider {
+    constructor(config) {
+        this.type = 'google';
+        this.defaultScope = [
+            'openid',
+            'https://www.googleapis.com/auth/userinfo.email',
+            'https://www.googleapis.com/auth/userinfo.profile'
+        ];
+        /**
+         * Rotas adicionais específicas do Google OAuth
+         */
+        this.additionalRoutes = [
+            // Rota de callback do Google
+            {
+                method: 'GET',
+                path: '/api/auth/callback/google',
+                handler: async (req, params) => {
+                    const url = new URL(req.url || '', 'http://localhost');
+                    const code = url.searchParams.get('code');
+                    if (!code) {
+                        return http_1.HightJSResponse.json({ error: 'Authorization code not provided' }, { status: 400 });
+                    }
+                    try {
+                        // Delega o 'code' para o endpoint de signin principal
+                        const authResponse = await fetch(`${req.headers.origin || 'http://localhost:3000'}/api/auth/signin`, {
+                            method: 'POST',
+                            headers: {
+                                'Content-Type': 'application/json',
+                            },
+                            body: JSON.stringify({
+                                provider: this.id,
+                                code,
+                            })
+                        });
+                        if (authResponse.ok) {
+                            // Propaga o cookie de sessão e redireciona para a URL de sucesso
+                            const setCookieHeader = authResponse.headers.get('set-cookie');
+                            if (this.config.successUrl) {
+                                return http_1.HightJSResponse
+                                    .redirect(this.config.successUrl)
+                                    .header('Set-Cookie', setCookieHeader || '');
+                            }
+                            return http_1.HightJSResponse.json({ success: true })
+                                .header('Set-Cookie', setCookieHeader || '');
+                        }
+                        else {
+                            const errorText = await authResponse.text();
+                            console.error(`[${this.id} Provider] Session creation failed during callback. Status: ${authResponse.status}, Body: ${errorText}`);
+                            return http_1.HightJSResponse.json({ error: 'Session creation failed' }, { status: 500 });
+                        }
+                    }
+                    catch (error) {
+                        console.error(`[${this.id} Provider] Callback handler fetch error:`, error);
+                        return http_1.HightJSResponse.json({ error: 'Internal server error' }, { status: 500 });
+                    }
+                }
+            }
+        ];
+        this.config = config;
+        this.id = config.id || 'google';
+        this.name = config.name || 'Google';
+    }
+    /**
+     * Método para gerar URL OAuth (usado pelo handleSignIn)
+     */
+    handleOauth(credentials = {}) {
+        return this.getAuthorizationUrl();
+    }
+    /**
+     * Método principal - redireciona para OAuth ou processa o callback
+     */
+    async handleSignIn(credentials) {
+        // Se tem código, é o callback - processa a autenticação
+        if (credentials.code) {
+            return await this.processOAuthCallback(credentials);
+        }
+        // Se não tem código, é o início do OAuth - retorna a URL
+        return this.handleOauth(credentials);
+    }
+    /**
+     * Processa o callback do OAuth (troca o código pelo usuário)
+     */
+    async processOAuthCallback(credentials) {
+        try {
+            const { code } = credentials;
+            if (!code) {
+                throw new Error('Authorization code not provided');
+            }
+            // Troca o código por um access token
+            const tokenResponse = await fetch('https://oauth2.googleapis.com/token', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                },
+                body: new URLSearchParams({
+                    client_id: this.config.clientId,
+                    client_secret: this.config.clientSecret,
+                    grant_type: 'authorization_code',
+                    code,
+                    redirect_uri: this.config.callbackUrl || '',
+                }),
+            });
+            if (!tokenResponse.ok) {
+                const error = await tokenResponse.text();
+                throw new Error(`Failed to exchange code for token: ${error}`);
+            }
+            const tokens = await tokenResponse.json();
+            // Busca os dados do usuário com o access token
+            const userResponse = await fetch('https://www.googleapis.com/oauth2/v2/userinfo', {
+                headers: {
+                    'Authorization': `Bearer ${tokens.access_token}`,
+                },
+            });
+            if (!userResponse.ok) {
+                throw new Error('Failed to fetch user data');
+            }
+            const googleUser = await userResponse.json();
+            // Retorna o objeto User padronizado
+            return {
+                id: googleUser.id,
+                name: googleUser.name,
+                email: googleUser.email,
+                image: googleUser.picture || null,
+                provider: this.id,
+                providerId: googleUser.id,
+                accessToken: tokens.access_token,
+                refreshToken: tokens.refresh_token
+            };
+        }
+        catch (error) {
+            console.error(`[${this.id} Provider] Error during OAuth callback:`, error);
+            return null;
+        }
+    }
+    /**
+     * Gera a URL de autorização do Google
+     */
+    getAuthorizationUrl() {
+        const params = new URLSearchParams({
+            client_id: this.config.clientId,
+            redirect_uri: this.config.callbackUrl || '',
+            response_type: 'code',
+            scope: (this.config.scope || this.defaultScope).join(' ')
+        });
+        return `https://accounts.google.com/o/oauth2/v2/auth?${params.toString()}`;
+    }
+    /**
+     * Retorna a configuração pública do provider
+     */
+    getConfig() {
+        return {
+            id: this.id,
+            name: this.name,
+            type: this.type,
+            clientId: this.config.clientId, // Público
+            scope: this.config.scope || this.defaultScope,
+            callbackUrl: this.config.callbackUrl
+        };
+    }
+}
+exports.GoogleProvider = GoogleProvider;

package/dist/auth/providers.d.ts

@@ -1,2 +1,3 @@
 export { CredentialsProvider } from './providers/credentials';
 export { DiscordProvider } from './providers/discord';
+export { GoogleProvider } from './providers/google';

package/dist/auth/providers.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DiscordProvider = exports.CredentialsProvider = void 0;
+exports.GoogleProvider = exports.DiscordProvider = exports.CredentialsProvider = void 0;
 // Exportações dos providers
 var credentials_1 = require("./providers/credentials");
 Object.defineProperty(exports, "CredentialsProvider", { enumerable: true, get: function () { return credentials_1.CredentialsProvider; } });
 var discord_1 = require("./providers/discord");
 Object.defineProperty(exports, "DiscordProvider", { enumerable: true, get: function () { return discord_1.DiscordProvider; } });
+var google_1 = require("./providers/google");
+Object.defineProperty(exports, "GoogleProvider", { enumerable: true, get: function () { return google_1.GoogleProvider; } });

package/dist/auth/types.d.ts

@@ -48,7 +48,11 @@ export interface AuthConfig {
     };
     callbacks?: {
         signIn?: (user: User, account: any, profile: any) => boolean | Promise<boolean>;
-        session?: (session: Session, user: User) => Session | Promise<Session>;
+        session?: ({ session, user, provider }: {
+            session: Session;
+            user: User;
+            provider: string;
+        }) => Session | Promise<Session>;
         jwt?: (token: any, user: User, account: any, profile: any) => any | Promise<any>;
     };
     session?: {
@@ -58,12 +62,7 @@ export interface AuthConfig {
     };
     secret?: string;
     debug?: boolean;
-}
-export interface AuthProvider {
-    id: string;
-    name: string;
-    type: 'credentials';
-    authorize?: (credentials: Record<string, string>) => Promise<User | null> | User | null;
+    secureCookies?: boolean;
 }
 export interface CredentialsConfig {
     id?: string;

package/dist/bin/hightjs.js

@@ -4,6 +4,8 @@
 require('ts-node').register();
 const { program } = require('commander');
 const teste = require("../helpers");
+const fs = require('fs');
+const path = require('path');
 program
     .version('1.0.0')
     .description('CLI para gerenciar a aplicação.');
@@ -31,5 +33,396 @@ program
     const t = teste.default({ dev: false, port: options.port, hostname: options.hostname, framework: options.framework });
     t.init();
 });
+// --- Comando EXPORT ---
+program
+    .command('export')
+    .description('Exporta a aplicação como HTML estático na pasta "exported".')
+    .option('-o, --output <path>', 'Especifica o diretório de saída', 'exported')
+    .action(async (options) => {
+    const projectDir = process.cwd();
+    const exportDir = path.join(projectDir, options.output);
+    console.log('🚀 Iniciando exportação...\n');
+    try {
+        // 1. Cria a pasta exported (limpa se já existir)
+        if (fs.existsSync(exportDir)) {
+            console.log('🗑️  Limpando pasta de exportação existente...');
+            fs.rmSync(exportDir, { recursive: true, force: true });
+        }
+        fs.mkdirSync(exportDir, { recursive: true });
+        console.log('✅ Pasta de exportação criada\n');
+        // 2. Inicializa e prepara o build
+        console.log('🔨 Buildando aplicação...');
+        const teste = require("../helpers");
+        const app = teste.default({ dev: false, port: 3000, hostname: '0.0.0.0', framework: 'native' });
+        await app.prepare();
+        console.log('✅ Build concluído\n');
+        // 3. Copia a pasta hweb-dist para exported
+        const distDir = path.join(projectDir, 'hweb-dist');
+        if (fs.existsSync(distDir)) {
+            console.log('📦 Copiando arquivos JavaScript...');
+            const exportDistDir = path.join(exportDir, 'hweb-dist');
+            fs.mkdirSync(exportDistDir, { recursive: true });
+            const files = fs.readdirSync(distDir);
+            files.forEach(file => {
+                fs.copyFileSync(path.join(distDir, file), path.join(exportDistDir, file));
+            });
+            console.log('✅ Arquivos JavaScript copiados\n');
+        }
+        // 4. Copia a pasta public se existir
+        const publicDir = path.join(projectDir, 'public');
+        if (fs.existsSync(publicDir)) {
+            console.log('📁 Copiando arquivos públicos...');
+            const exportPublicDir = path.join(exportDir, 'public');
+            function copyRecursive(src, dest) {
+                if (fs.statSync(src).isDirectory()) {
+                    fs.mkdirSync(dest, { recursive: true });
+                    fs.readdirSync(src).forEach(file => {
+                        copyRecursive(path.join(src, file), path.join(dest, file));
+                    });
+                }
+                else {
+                    fs.copyFileSync(src, dest);
+                }
+            }
+            copyRecursive(publicDir, exportPublicDir);
+            console.log('✅ Arquivos públicos copiados\n');
+        }
+        // 5. Gera o index.html
+        console.log('📝 Gerando index.html...');
+        const { render } = require('../renderer');
+        const { loadRoutes, loadLayout, loadNotFound } = require('../router');
+        // Carrega as rotas para gerar o HTML
+        const userWebDir = path.join(projectDir, 'src', 'web');
+        const userWebRoutesDir = path.join(userWebDir, 'routes');
+        const routes = loadRoutes(userWebRoutesDir);
+        loadLayout(userWebDir);
+        loadNotFound(userWebDir);
+        // Gera HTML para a rota raiz
+        const rootRoute = routes.find(r => r.pattern === '/') || routes[0];
+        if (rootRoute) {
+            const mockReq = {
+                url: '/',
+                method: 'GET',
+                headers: { host: 'localhost' },
+                hwebDev: false,
+                hotReloadManager: null
+            };
+            const html = await render({
+                req: mockReq,
+                route: rootRoute,
+                params: {},
+                allRoutes: routes
+            });
+            const indexPath = path.join(exportDir, 'index.html');
+            fs.writeFileSync(indexPath, html, 'utf8');
+            console.log('✅ index.html gerado\n');
+        }
+        console.log('🎉 Exportação concluída com sucesso!');
+        console.log(`📂 Arquivos exportados em: ${exportDir}\n`);
+    }
+    catch (error) {
+        console.error('❌ Erro durante a exportação:', error.message);
+        process.exit(1);
+    }
+});
+// --- Comando MIGRATE FROM NEXTJS ---
+program
+    .command('migrate-from-nextjs')
+    .description('Migra um projeto Next.js para HightJS.')
+    .option('-s, --source <path>', 'Caminho do projeto Next.js', process.cwd())
+    .option('-o, --output <path>', 'Diretório de saída para o projeto HightJS', './hightjs-project')
+    .action(async (options) => {
+    const sourcePath = path.resolve(options.source);
+    const outputPath = path.resolve(options.output);
+    console.log('🚀 Iniciando migração de Next.js para HightJS...\n');
+    console.log(`📂 Origem: ${sourcePath}`);
+    console.log(`📂 Destino: ${outputPath}\n`);
+    try {
+        // Verifica se o diretório de origem existe
+        if (!fs.existsSync(sourcePath)) {
+            throw new Error(`Diretório de origem não encontrado: ${sourcePath}`);
+        }
+        // Verifica se é um projeto Next.js
+        const nextConfigPath = path.join(sourcePath, 'next.config.js');
+        const nextConfigMjsPath = path.join(sourcePath, 'next.config.mjs');
+        const packageJsonPath = path.join(sourcePath, 'package.json');
+        if (!fs.existsSync(nextConfigPath) && !fs.existsSync(nextConfigMjsPath) && !fs.existsSync(packageJsonPath)) {
+            throw new Error('Não foi encontrado um projeto Next.js válido no diretório especificado.');
+        }
+        // Cria o diretório de saída
+        if (fs.existsSync(outputPath)) {
+            console.log('⚠️  Diretório de destino já existe. Limpando...');
+            fs.rmSync(outputPath, { recursive: true, force: true });
+        }
+        fs.mkdirSync(outputPath, { recursive: true });
+        // 1. Cria estrutura básica do HightJS
+        console.log('📁 Criando estrutura de diretórios...');
+        const srcDir = path.join(outputPath, 'src');
+        const webDir = path.join(srcDir, 'web');
+        const routesDir = path.join(webDir, 'routes');
+        const publicDir = path.join(outputPath, 'public');
+        fs.mkdirSync(srcDir, { recursive: true });
+        fs.mkdirSync(webDir, { recursive: true });
+        fs.mkdirSync(routesDir, { recursive: true });
+        fs.mkdirSync(publicDir, { recursive: true });
+        // 2. Copia arquivos públicos
+        console.log('📦 Copiando arquivos públicos...');
+        const nextPublicDir = path.join(sourcePath, 'public');
+        if (fs.existsSync(nextPublicDir)) {
+            copyDirectory(nextPublicDir, publicDir);
+        }
+        // 3. Migra páginas do Next.js para rotas do HightJS
+        console.log('🔄 Migrando páginas para rotas...');
+        const nextPagesDir = path.join(sourcePath, 'pages');
+        const nextAppDir = path.join(sourcePath, 'app');
+        const nextSrcPagesDir = path.join(sourcePath, 'src', 'pages');
+        const nextSrcAppDir = path.join(sourcePath, 'src', 'app');
+        let pagesDir = null;
+        let isAppRouter = false;
+        if (fs.existsSync(nextAppDir)) {
+            pagesDir = nextAppDir;
+            isAppRouter = true;
+            console.log('✅ Detectado Next.js App Router');
+        }
+        else if (fs.existsSync(nextSrcAppDir)) {
+            pagesDir = nextSrcAppDir;
+            isAppRouter = true;
+            console.log('✅ Detectado Next.js App Router (em src/)');
+        }
+        else if (fs.existsSync(nextPagesDir)) {
+            pagesDir = nextPagesDir;
+            console.log('✅ Detectado Next.js Pages Router');
+        }
+        else if (fs.existsSync(nextSrcPagesDir)) {
+            pagesDir = nextSrcPagesDir;
+            console.log('✅ Detectado Next.js Pages Router (em src/)');
+        }
+        if (pagesDir) {
+            if (isAppRouter) {
+                migrateAppRouter(pagesDir, routesDir);
+            }
+            else {
+                migratePagesRouter(pagesDir, routesDir);
+            }
+        }
+        // 5. Cria package.json
+        console.log('📄 Criando package.json...');
+        let originalPackageJson = {};
+        if (fs.existsSync(packageJsonPath)) {
+            originalPackageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        }
+        const newPackageJson = {
+            name: originalPackageJson.name || 'hightjs-app',
+            version: '1.0.0',
+            description: originalPackageJson.description || 'HightJS application migrated from Next.js',
+            scripts: {
+                dev: 'hight dev',
+                start: 'hight start',
+                build: 'hight export',
+                ...originalPackageJson.scripts
+            },
+            dependencies: {
+                hightjs: 'latest',
+                react: originalPackageJson.dependencies?.react || '^18.2.0',
+                'react-dom': originalPackageJson.dependencies?.['react-dom'] || '^18.2.0',
+                ...filterDependencies(originalPackageJson.dependencies)
+            },
+            devDependencies: {
+                '@types/node': '^20.11.24',
+                '@types/react': '^18.2.0',
+                '@types/react-dom': '^18.2.0',
+                typescript: '^5.3.3',
+                ...filterDependencies(originalPackageJson.devDependencies)
+            }
+        };
+        fs.writeFileSync(path.join(outputPath, 'package.json'), JSON.stringify(newPackageJson, null, 2), 'utf8');
+        // 6. Cria tsconfig.json
+        console.log('⚙️  Criando tsconfig.json...');
+        const tsConfig = {
+            compilerOptions: {
+                target: 'ES2020',
+                lib: ['ES2020', 'DOM', 'DOM.Iterable'],
+                jsx: 'react-jsx',
+                module: 'commonjs',
+                moduleResolution: 'node',
+                esModuleInterop: true,
+                strict: true,
+                skipLibCheck: true,
+                forceConsistentCasingInFileNames: true,
+                resolveJsonModule: true,
+                allowSyntheticDefaultImports: true
+            },
+            include: ['src/**/*'],
+            exclude: ['node_modules']
+        };
+        fs.writeFileSync(path.join(outputPath, 'tsconfig.json'), JSON.stringify(tsConfig, null, 2), 'utf8');
+        // 7. Cria README
+        console.log('📖 Criando README...');
+        const readmeContent = `# ${originalPackageJson.name || 'HightJS App'}
+
+Este projeto foi migrado de Next.js para HightJS.
+
+## Comandos Disponíveis
+
+- \`npm run dev\` - Inicia o servidor de desenvolvimento
+- \`npm run start\` - Inicia o servidor em modo produção
+- \`npm run build\` - Exporta a aplicação como HTML estático
+
+## Próximos Passos
+
+1. Instale as dependências: \`npm install\`
+2. Revise os arquivos migrados em \`src/web/routes/\`
+3. Ajuste manualmente qualquer código que precise de adaptação
+4. Execute \`npm run dev\` para testar
+
+## Notas de Migração
+
+- Rotas dinâmicas do Next.js foram convertidas para o formato HightJS
+- API Routes precisam ser migradas manualmente para HightJS API routes
+- Server Components foram convertidos para componentes React padrão
+- Revise imports e configurações específicas do Next.js
+
+Para mais informações sobre HightJS, visite a documentação.
+`;
+        fs.writeFileSync(path.join(outputPath, 'README.md'), readmeContent, 'utf8');
+        console.log('\n✅ Migração concluída com sucesso!');
+        console.log(`\n📂 Projeto criado em: ${outputPath}`);
+        console.log('\n📋 Próximos passos:');
+        console.log(`   1. cd ${path.relative(process.cwd(), outputPath)}`);
+        console.log('   2. npm install');
+        console.log('   3. npm run dev');
+        console.log('\n⚠️  IMPORTANTE: Revise os arquivos migrados e ajuste conforme necessário.\n');
+    }
+    catch (error) {
+        console.error('❌ Erro durante a migração:', error.message);
+        console.error(error.stack);
+        process.exit(1);
+    }
+});
+// Funções auxiliares para migração
+function copyDirectory(src, dest) {
+    if (!fs.existsSync(src))
+        return;
+    fs.mkdirSync(dest, { recursive: true });
+    const entries = fs.readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            copyDirectory(srcPath, destPath);
+        }
+        else {
+            fs.copyFileSync(srcPath, destPath);
+        }
+    }
+}
+function migratePagesRouter(pagesDir, routesDir) {
+    function processDirectory(dir, baseRoute = '') {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                // Processa subdiretórios (rotas aninhadas)
+                const newBaseRoute = path.join(baseRoute, entry.name);
+                processDirectory(fullPath, newBaseRoute);
+            }
+            else if (entry.name.match(/\.(tsx?|jsx?)$/)) {
+                // Ignora arquivos especiais do Next.js
+                if (['_app', '_document', '_error', 'api'].some(special => entry.name.startsWith(special))) {
+                    continue;
+                }
+                // Converte nome do arquivo para rota HightJS
+                let fileName = entry.name.replace(/\.(tsx?|jsx?)$/, '');
+                let routePath = baseRoute;
+                if (fileName === 'index') {
+                    // index.tsx -> route vazia ou baseRoute
+                    routePath = baseRoute || '/';
+                }
+                else {
+                    // [id].tsx -> $id.tsx
+                    fileName = fileName.replace(/\[([^\]]+)\]/g, '$$$1');
+                    routePath = path.join(baseRoute, fileName);
+                }
+                // Lê o conteúdo original
+                const originalContent = fs.readFileSync(fullPath, 'utf8');
+                // Transforma o conteúdo
+                const transformedContent = transformNextJsPage(originalContent);
+                // Cria estrutura de diretórios se necessário
+                const targetDir = path.join(routesDir, baseRoute);
+                fs.mkdirSync(targetDir, { recursive: true });
+                // Salva o arquivo transformado
+                const targetFileName = fileName === 'index' ? 'route.tsx' : `${fileName}.route.tsx`;
+                const targetPath = path.join(targetDir, targetFileName);
+                fs.writeFileSync(targetPath, transformedContent, 'utf8');
+                console.log(`   ✓ ${path.relative(pagesDir, fullPath)} -> ${path.relative(routesDir, targetPath)}`);
+            }
+        }
+    }
+    processDirectory(pagesDir);
+}
+function migrateAppRouter(appDir, routesDir) {
+    function processDirectory(dir, baseRoute = '') {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        let hasPage = false;
+        for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                // Suporta rotas dinâmicas como [id]
+                let dirName = entry.name;
+                if (dirName.startsWith('[') && dirName.endsWith(']')) {
+                    dirName = '$' + dirName.slice(1, -1);
+                }
+                const newBaseRoute = path.join(baseRoute, dirName);
+                processDirectory(fullPath, newBaseRoute);
+            }
+            else if (entry.name === 'page.tsx' || entry.name === 'page.jsx' || entry.name === 'page.ts' || entry.name === 'page.js') {
+                hasPage = true;
+                // Lê o conteúdo original
+                const originalContent = fs.readFileSync(fullPath, 'utf8');
+                // Transforma o conteúdo
+                const transformedContent = transformNextJsPage(originalContent);
+                // Cria estrutura de diretórios
+                const targetDir = path.join(routesDir, baseRoute);
+                fs.mkdirSync(targetDir, { recursive: true });
+                // Salva como route.tsx
+                const targetPath = path.join(targetDir, 'route.tsx');
+                fs.writeFileSync(targetPath, transformedContent, 'utf8');
+                console.log(`   ✓ ${path.relative(appDir, fullPath)} -> ${path.relative(routesDir, targetPath)}`);
+            }
+        }
+    }
+    processDirectory(appDir);
+}
+function transformNextJsPage(content) {
+    // Remove 'use client' e 'use server'
+    content = content.replace(/['"]use (client|server)['"]\s*;\s*/g, '');
+    // Remove imports específicos do Next.js
+    content = content.replace(/import\s+.*?from\s+['"]next\/.*?['"];?\s*/g, '');
+    // Substitui Link do Next.js por Link do HightJS
+    if (content.includes('Link')) {
+        content = `import { Link } from 'hightjs/client';\n` + content;
+    }
+    // Substitui useRouter do Next.js
+    content = content.replace(/import\s*\{\s*useRouter\s*\}\s*from\s*['"]next\/router['"]/g, "import { useRouter } from 'hightjs/client'");
+    // Substitui Image do Next.js por img normal (com comentário para revisão)
+    content = content.replace(/<Image\s+/g, '<img /* TODO: Migrado de Next.js Image - revisar otimizações */ ');
+    // Remove getServerSideProps, getStaticProps, getStaticPaths
+    content = content.replace(/export\s+(async\s+)?function\s+get(ServerSideProps|StaticProps|StaticPaths)\s*\([^)]*\)\s*\{[\s\S]*?\n\}/g, '');
+    // Adiciona comentário sobre metadata se houver
+    if (content.includes('export const metadata')) {
+        content = '// TODO: Migrar metadata do Next.js para HightJS\n' + content;
+    }
+    return content.trim();
+}
+function filterDependencies(deps) {
+    if (!deps)
+        return {};
+    const filtered = { ...deps };
+    // Remove dependências específicas do Next.js
+    delete filtered.next;
+    delete filtered['@next/font'];
+    delete filtered['next-auth'];
+    return filtered;
+}
 // Faz o "parse" dos argumentos passados na linha de comando
 program.parse(process.argv);

package/dist/client/entry.client.js

@@ -49,7 +49,17 @@ function App({ componentMap, routes, initialComponentPath, initialParams, layout
     const [params, setParams] = (0, react_1.useState)(initialParams);
     const findRouteForPath = (0, react_1.useCallback)((path) => {
         for (const route of routes) {
-            const regexPattern = route.pattern.replace(/\[(\w+)\]/g, '(?<$1>[^/]+)');
+            const regexPattern = route.pattern
+                // [[...param]] → opcional catch-all
+                .replace(/\[\[\.\.\.(\w+)\]\]/g, '(?<$1>.+)?')
+                // [...param] → obrigatório catch-all
+                .replace(/\[\.\.\.(\w+)\]/g, '(?<$1>.+)')
+                // /[[param]] → opcional com barra também opcional
+                .replace(/\/\[\[(\w+)\]\]/g, '(?:/(?<$1>[^/]+))?')
+                // [[param]] → segmento opcional (sem barra anterior)
+                .replace(/\[\[(\w+)\]\]/g, '(?<$1>[^/]+)?')
+                // [param] → segmento obrigatório
+                .replace(/\[(\w+)\]/g, '(?<$1>[^/]+)');
             const regex = new RegExp(`^${regexPattern}/?$`);
             const match = path.match(regex);
             if (match) {