hightjs 0.4.0 → 0.5.0

package/src/bin/hightjs.js

@@ -1,222 +0,0 @@
-#!/usr/bin/env node
-
-/*
- * This file is part of the HightJS Project.
- * Copyright (c) 2025 itsmuzin
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-
-// Registra o ts-node para que o Node.js entenda TypeScript/TSX
-require('ts-node').register();
-
-const { program } = require('commander');
-
-
-program
-    .version('1.0.0')
-    .description('CLI to manage the application.');
-
-// --- Comando DEV ---
-const fs = require('fs');
-const path = require('path');
-// 'program' já deve estar definido no seu arquivo
-// const { program } = require('commander');
-
-/**
- * Função centralizada para iniciar a aplicação
- * @param {object} options - Opções vindas do commander
- * @param {boolean} isDev - Define se é modo de desenvolvimento
- */
-function initializeApp(options, isDev) {
-    const appOptions = {
-        dev: isDev,
-        port: options.port,
-        hostname: options.hostname,
-        framework: 'native',
-        ssl: null, // Default
-    };
-
-    // 1. Verifica se a flag --ssl foi ativada
-    if (options.ssl) {
-        const C = require("../api/console")
-        const { Levels } = C;
-        const Console = C.default
-        const sslDir = path.resolve(process.cwd(), 'certs');
-        const keyPath = path.join(sslDir, 'key.pem'); // Padrão 1: key.pem
-        const certPath = path.join(sslDir, 'cert.pem'); // Padrão 2: cert.pem
-        // (Você pode mudar para 'cert.key' se preferir, apenas ajuste os nomes aqui)
-
-        // 2. Verifica se os arquivos existem
-        if (fs.existsSync(keyPath) && fs.existsSync(certPath)) {
-            appOptions.ssl = {
-                key: keyPath,
-                cert: certPath
-            };
-
-            // 3. Adiciona a porta de redirecionamento (útil para o initNativeServer)
-            appOptions.ssl.redirectPort = options.httpRedirectPort || 80;
-
-        } else {
-            Console.logWithout(Levels.ERROR, null, `Ensure that './certs/key.pem' and './certs/cert.pem' exist.`, `--ssl flag was used, but the files were not found.`)
-
-
-            process.exit(1); // Encerra o processo com erro
-        }
-    }
-
-    // 4. Inicia o helper com as opções
-    const teste = require("../helpers");
-    const t = teste.default(appOptions);
-    t.init();
-}
-
-// --- Comando DEV ---
-program
-    .command('dev')
-    .description('Starts the application in development mode.')
-    .option('-p, --port <number>', 'Specifies the port to run on', '3000')
-    .option('-H, --hostname <string>', 'Specifies the hostname to run on', '0.0.0.0')
-    .option('--ssl', 'Activates HTTPS/SSL mode (requires ./ssl/key.pem and ./ssl/cert.pem)')
-    .option('--http-redirect-port <number>', 'Port for HTTP->HTTPS redirection', '80')
-    .action((options) => {
-        initializeApp(options, true); // Chama a função com dev: true
-    });
-
-// --- Comando START (Produção) ---
-program
-    .command('start')
-    .description('Starts the application in production mode.')
-    .option('-p, --port <number>', 'Specifies the port to run on', '3000')
-    .option('-H, --hostname <string>', 'Specifies the hostname to run on', '0.0.0.0')
-    .option('--ssl', 'Activates HTTPS/SSL mode (requires ./ssl/key.pem and ./ssl/cert.pem)')
-    .option('--http-redirect-port <number>', 'Port for HTTP->HTTPS redirection', '80')
-    .action((options) => {
-        initializeApp(options, false); // Chama a função com dev: false
-    });
-
-// --- Comando EXPORT ---
-program
-    .command('export')
-    .description('Exports the application as static HTML to the "exported" folder.')
-    .option('-o, --output <path>', 'Specifies the output directory', 'exported')
-    .action(async (options) => {
-        const projectDir = process.cwd();
-        const exportDir = path.join(projectDir, options.output);
-
-        console.log('🚀 Starting export...\n');
-
-        try {
-            // 1. Cria a pasta exported (limpa se já existir)
-            if (fs.existsSync(exportDir)) {
-                console.log('🗑️  Cleaning existing export folder...');
-                fs.rmSync(exportDir, { recursive: true, force: true });
-            }
-            fs.mkdirSync(exportDir, { recursive: true });
-            console.log('✅ Export folder created\n');
-
-            // 2. Inicializa e prepara o build
-            console.log('🔨 Building application...');
-            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 complete\n');
-
-            // 3. Copia a pasta .hight para exported
-            const distDir = path.join(projectDir, '.hight');
-            if (fs.existsSync(distDir)) {
-                console.log('📦 Copying JavaScript files...');
-                const exportDistDir = path.join(exportDir, '.hight');
-                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('✅ JavaScript files copied\n');
-            }
-
-            // 4. Copia a pasta public se existir
-            const publicDir = path.join(projectDir, 'public');
-            if (fs.existsSync(publicDir)) {
-                console.log('📁 Copying public files...');
-                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('✅ Public files copied\n');
-            }
-
-            // 5. Gera o index.html
-            console.log('📝 Generating 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 generated\n');
-            }
-
-            console.log('🎉 Export completed successfully!');
-            console.log(`📂 Files exported to: ${exportDir}\n`);
-
-        } catch (error) {
-            console.error('❌ Error during export:', error.message);
-            process.exit(1);
-        }
-    });
-
-
-// Faz o "parse" dos argumentos passados na linha de comando
-program.parse(process.argv);

package/src/builder.js

@@ -1,472 +0,0 @@
-/*
- * This file is part of the HightJS Project.
- * Copyright (c) 2025 itsmuzin
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-const esbuild = require('esbuild');
-const path = require('path');
-const Console = require("./api/console").default
-const fs = require('fs');
-const {readdir, stat} = require("node:fs/promises");
-const {rm} = require("fs-extra");
-// Lista de módulos nativos do Node.js para marcar como externos (apenas os built-ins do Node)
-const nodeBuiltIns = [
-    'assert', 'buffer', 'child_process', 'cluster', 'crypto', 'dgram', 'dns', 
-    'domain', 'events', 'fs', 'http', 'https', 'net', 'os', 'path', 'punycode', 
-    'querystring', 'readline', 'stream', 'string_decoder', 'tls', 'tty', 'url', 
-    'util', 'v8', 'vm', 'zlib', 'module', 'worker_threads', 'perf_hooks'
-];
-
-/**
- * Plugin para processar CSS com PostCSS e Tailwind
- */
-const postcssPlugin = {
-    name: 'postcss-plugin',
-    setup(build) {
-        build.onLoad({ filter: /\.css$/ }, async (args) => {
-            const fs = require('fs');
-            const path = require('path');
-
-            try {
-                // Lê o CSS original
-                let css = await fs.promises.readFile(args.path, 'utf8');
-
-                // Verifica se tem PostCSS config no projeto
-                const projectDir = process.cwd();
-                const postcssConfigPath = path.join(projectDir, 'postcss.config.js');
-                const postcssConfigMjsPath = path.join(projectDir, 'postcss.config.mjs');
-
-                let processedCss = css;
-
-                if (fs.existsSync(postcssConfigPath) || fs.existsSync(postcssConfigMjsPath)) {
-                    try {
-                        // Importa PostCSS do projeto (não do SDK)
-                        const postcssPath = path.join(projectDir, 'node_modules', 'postcss');
-                        const postcss = require(postcssPath);
-
-                        // Carrega a config do PostCSS
-                        const configPath = fs.existsSync(postcssConfigPath) ? postcssConfigPath : postcssConfigMjsPath;
-                        delete require.cache[require.resolve(configPath)];
-                        const config = require(configPath);
-                        const postcssConfig = config.default || config;
-
-                        // Resolve plugins do projeto
-                        const plugins = [];
-
-                        if (postcssConfig.plugins) {
-                            if (Array.isArray(postcssConfig.plugins)) {
-                                // Formato array: ["@tailwindcss/postcss"]
-                                plugins.push(...postcssConfig.plugins.map(plugin => {
-                                    if (typeof plugin === 'string') {
-                                        try {
-                                            // Tenta resolver do node_modules do projeto primeiro
-                                            return require.resolve(plugin, { paths: [projectDir] });
-                                        } catch {
-                                            // Fallback para require direto
-                                            return require(plugin);
-                                        }
-                                    }
-                                    return plugin;
-                                }));
-                            } else {
-                                // Formato objeto: { tailwindcss: {}, autoprefixer: {} }
-                                for (const [pluginName, pluginOptions] of Object.entries(postcssConfig.plugins)) {
-                                    try {
-                                        // Resolve o plugin do projeto
-                                        const resolvedPath = require.resolve(pluginName, { paths: [projectDir] });
-                                        const pluginModule = require(resolvedPath);
-                                        plugins.push(pluginModule(pluginOptions || {}));
-                                    } catch (error) {
-                                        Console.warn(`Unable to load plugin ${pluginName}:`, error.message);
-                                    }
-                                }
-                            }
-                        }
-
-                        // Processa o CSS com PostCSS
-                        const result = await postcss(plugins)
-                            .process(css, {
-                                from: args.path,
-                                to: args.path.replace(/\.css$/, '.processed.css')
-                            });
-
-                        processedCss = result.css;
-
-                    } catch (postcssError) {
-                        Console.warn(`Error processing CSS with PostCSS:`, postcssError.message);
-                        Console.warn(`Using raw CSS without processing.`);
-                    }
-                }
-
-                return {
-                    contents: `
-                        const css = ${JSON.stringify(processedCss)};
-                        if (typeof document !== 'undefined') {
-                            const style = document.createElement('style');
-                            style.textContent = css;
-                            document.head.appendChild(style);
-                        }
-                        export default css;
-                    `,
-                    loader: 'js'
-                };
-
-            } catch (error) {
-                Console.error(`Erro ao processar CSS ${args.path}:`, error);
-                return {
-                    contents: `export default "";`,
-                    loader: 'js'
-                };
-            }
-        });
-    }
-};
-
-/**
- * Plugin para resolver dependências npm no frontend
- */
-const npmDependenciesPlugin = {
-    name: 'npm-dependencies',
-    setup(build) {
-        // Permite que dependências npm sejam bundladas (não marcadas como external)
-        build.onResolve({ filter: /^[^./]/ }, (args) => {
-            // Se for um módulo built-in do Node.js, marca como external
-            if (nodeBuiltIns.includes(args.path)) {
-                return { path: args.path, external: true };
-            }
-
-            // Para dependências npm (axios, lodash, react, react-dom, etc), deixa o esbuild resolver normalmente
-            // Isso permite que sejam bundladas no frontend
-            return null;
-        });
-    }
-};
-
-/**
- * Plugin para garantir que React seja corretamente resolvido
- */
-const reactResolvePlugin = {
-    name: 'react-resolve',
-    setup(build) {
-        // Força o uso de uma única instância do React do projeto
-        build.onResolve({ filter: /^react$/ }, (args) => {
-            const reactPath = require.resolve('react', { paths: [process.cwd()] });
-            return {
-                path: reactPath
-            };
-        });
-
-        build.onResolve({ filter: /^react-dom$/ }, (args) => {
-            const reactDomPath = require.resolve('react-dom', { paths: [process.cwd()] });
-            return {
-                path: reactDomPath
-            };
-        });
-
-        build.onResolve({ filter: /^react\/jsx-runtime$/ }, (args) => {
-            const jsxRuntimePath = require.resolve('react/jsx-runtime', { paths: [process.cwd()] });
-            return {
-                path: jsxRuntimePath
-            };
-        });
-
-        // Também resolve react-dom/client para React 18+
-        build.onResolve({ filter: /^react-dom\/client$/ }, (args) => {
-            const clientPath = require.resolve('react-dom/client', { paths: [process.cwd()] });
-            return {
-                path: clientPath
-            };
-        });
-    }
-};
-
-/**
- * Plugin para adicionar suporte a HMR (Hot Module Replacement)
- */
-const hmrPlugin = {
-    name: 'hmr-plugin',
-    setup(build) {
-        // Adiciona runtime de HMR para arquivos TSX/JSX
-        build.onLoad({ filter: /\.(tsx|jsx)$/ }, async (args) => {
-            // Ignora arquivos de node_modules
-            if (args.path.includes('node_modules')) {
-                return null;
-            }
-
-            const fs = require('fs');
-            const contents = await fs.promises.readFile(args.path, 'utf8');
-
-            // Adiciona código de HMR apenas em componentes de rota
-            if (args.path.includes('/routes/') || args.path.includes('\\routes\\')) {
-                const hmrCode = `
-// HMR Runtime
-if (typeof window !== 'undefined' && window.__HWEB_HMR__) {
-    const moduleId = ${JSON.stringify(args.path)};
-    if (!window.__HWEB_HMR_MODULES__) {
-        window.__HWEB_HMR_MODULES__ = new Map();
-    }
-    window.__HWEB_HMR_MODULES__.set(moduleId, module.exports);
-}
-`;
-                return {
-                    contents: contents + '\n' + hmrCode,
-                    loader: 'tsx'
-                };
-            }
-
-            return null;
-        });
-    }
-};
-
-/**
- * Builds with code splitting into multiple chunks based on module types.
- * @param {string} entryPoint - The path to the entry file.
- * @param {string} outdir - The directory for output files.
- * @param {boolean} isProduction - Se está em modo produção ou não.
- * @returns {Promise<void>}
- */
-async function buildWithChunks(entryPoint, outdir, isProduction = false) {
-    // limpar diretorio, menos a pasta temp
-    await cleanDirectoryExcept(outdir, 'temp');
-
-  try {
-    await esbuild.build({
-      entryPoints: [entryPoint],
-      bundle: true,
-      minify: isProduction,
-      sourcemap: !isProduction,
-      platform: 'browser',
-      outdir: outdir,
-      loader: { '.js': 'jsx', '.ts': 'tsx' },
-      external: nodeBuiltIns,
-      plugins: [postcssPlugin, npmDependenciesPlugin, reactResolvePlugin],
-      format: 'esm', // ESM suporta melhor o code splitting
-      jsx: 'automatic',
-      define: {
-        'process.env.NODE_ENV': isProduction ? '"production"' : '"development"'
-      },
-      conditions: ['development'],
-      mainFields: ['browser', 'module', 'main'],
-      resolveExtensions: ['.tsx', '.ts', '.jsx', '.js'],
-      splitting: true,
-      chunkNames: 'chunks/[name]-[hash]',
-      // Força o nome do entry para main(.js) ou main-[hash].js em prod
-      entryNames: isProduction ? 'main-[hash]' : 'main',
-      keepNames: true,
-      treeShaking: true,
-    });
-
-  } catch (error) {
-    console.error('An error occurred while building:', error);
-    process.exit(1);
-  }
-}
-
-/**
- * Watches with code splitting enabled
- * @param {string} entryPoint - The path to the entry file.
- * @param {string} outdir - The directory for output files.
- * @param {Object} hotReloadManager - Manager de hot reload (opcional).
- * @returns {Promise<void>}
- */
-async function watchWithChunks(entryPoint, outdir, hotReloadManager = null) {
-    // limpar diretorio
-    await cleanDirectoryExcept(outdir, 'temp');
-    try {
-        // Plugin para notificar quando o build termina
-        const buildCompletePlugin = {
-            name: 'build-complete',
-            setup(build) {
-                let isFirstBuild = true;
-                build.onEnd((result) => {
-                    if (hotReloadManager) {
-                        if (isFirstBuild) {
-                            isFirstBuild = false;
-                            hotReloadManager.onBuildComplete(true);
-                        } else {
-                            // Notifica o hot reload manager que o build foi concluído
-                            hotReloadManager.onBuildComplete(result.errors.length === 0);
-                        }
-                    }
-                });
-            }
-        };
-
-        const context = await esbuild.context({
-            entryPoints: [entryPoint],
-            bundle: true,
-            minify: false,
-            sourcemap: true,
-            platform: 'browser',
-            outdir: outdir,
-            loader: { '.js': 'jsx', '.ts': 'tsx' },
-            external: nodeBuiltIns,
-            plugins: [postcssPlugin, npmDependenciesPlugin, reactResolvePlugin, hmrPlugin, buildCompletePlugin],
-            format: 'esm',
-            jsx: 'automatic',
-            define: {
-                'process.env.NODE_ENV': '"development"'
-            },
-            conditions: ['development'],
-            mainFields: ['browser', 'module', 'main'],
-            resolveExtensions: ['.tsx', '.ts', '.jsx', '.js'],
-            splitting: true,
-            chunkNames: 'chunks/[name]-[hash]',
-            entryNames: 'main',
-            keepNames: true,
-            treeShaking: true,
-        });
-
-        await context.watch();
-    } catch (error) {
-        console.error(error)
-        Console.error('Error starting watch mode with chunks:', error);
-        throw error;
-    }
-}
-
-/**
- * Builds a single entry point into a single output file.
- * @param {string} entryPoint - The path to the entry file.
- * @param {string} outfile - The full path to the output file.
- * @param {boolean} isProduction - Se está em modo produção ou não.
- * @returns {Promise<void>}
- */
-async function build(entryPoint, outfile, isProduction = false) {
-    // limpar diretorio do outfile
-    const outdir = path.dirname(outfile);
-    await cleanDirectoryExcept(outdir, 'temp');
-
-  try {
-    await esbuild.build({
-      entryPoints: [entryPoint],
-      bundle: true,
-      minify: isProduction,
-      sourcemap: !isProduction, // Só gera sourcemap em dev
-      platform: 'browser',
-      outfile: outfile,
-      loader: { '.js': 'jsx', '.ts': 'tsx' },
-      external: nodeBuiltIns,
-      plugins: [postcssPlugin, npmDependenciesPlugin, reactResolvePlugin],
-      format: 'iife',
-      globalName: 'HwebApp',
-      jsx: 'automatic',
-      define: {
-        'process.env.NODE_ENV': isProduction ? '"production"' : '"development"'
-      },
-      // Configurações específicas para React 19
-      conditions: ['development'],
-      mainFields: ['browser', 'module', 'main'],
-      resolveExtensions: ['.tsx', '.ts', '.jsx', '.js'],
-      // Garante que não há duplicação de dependências
-      splitting: false,
-      // Preserva nomes de funções e comportamento
-      keepNames: true,
-      // Remove otimizações que podem causar problemas com hooks
-      treeShaking: true,
-      drop: [], // Não remove nada automaticamente
-    });
-
-  } catch (error) {
-    console.error('An error occurred during build:', error);
-    process.exit(1);
-  }
-}
-
-/**
- * Watches an entry point and its dependencies, rebuilding to a single output file.
- * @param {string} entryPoint - The path to the entry file.
- * @param {string} outfile - The full path to the output file.
- * @param {Object} hotReloadManager - Manager de hot reload (opcional).
- * @returns {Promise<void>}
- */
-async function watch(entryPoint, outfile, hotReloadManager = null) {
-    try {
-        // Plugin para notificar quando o build termina
-        const buildCompletePlugin = {
-            name: 'build-complete',
-            setup(build) {
-                let isFirstBuild = true;
-                build.onEnd((result) => {
-                    if (hotReloadManager) {
-                        if (isFirstBuild) {
-                            isFirstBuild = false;
-                            hotReloadManager.onBuildComplete(true);
-                        } else {
-                            // Notifica o hot reload manager que o build foi concluído
-                            hotReloadManager.onBuildComplete(result.errors.length === 0);
-                        }
-                    }
-                });
-            }
-        };
-
-        const context = await esbuild.context({
-            entryPoints: [entryPoint],
-            bundle: true,
-            minify: false,
-            sourcemap: true,
-            platform: 'browser',
-            outfile: outfile,
-            loader: { '.js': 'jsx', '.ts': 'tsx' },
-            external: nodeBuiltIns,
-            plugins: [postcssPlugin, npmDependenciesPlugin, reactResolvePlugin, buildCompletePlugin],
-            format: 'iife',
-            globalName: 'HwebApp',
-            jsx: 'automatic',
-            define: {
-                'process.env.NODE_ENV': '"development"'
-            },
-            // Configurações específicas para React 19 (mesmo que no build)
-            conditions: ['development'],
-            mainFields: ['browser', 'module', 'main'],
-            resolveExtensions: ['.tsx', '.ts', '.jsx', '.js'],
-            // Garante que não há duplicação de dependências
-            splitting: false,
-            // Preserva nomes de funções e comportamento
-            keepNames: true,
-            // Remove otimizações que podem causar problemas com hooks
-            treeShaking: true,
-        });
-
-        // Configura o watcher do esbuild
-        await context.watch();
-    } catch (error) {
-        Console.error('Error starting watch mode:', error);
-        throw error;
-    }
-}
-/**
- * Remove todo o conteúdo de um diretório,
- * exceto a pasta (ou pastas) especificada(s) em excludeFolder.
- *
- * @param {string} dirPath - Caminho do diretório a limpar
- * @param {string|string[]} excludeFolder - Nome ou nomes das pastas a manter
- */
-async function cleanDirectoryExcept(dirPath, excludeFolder) {
-    const excludes = Array.isArray(excludeFolder) ? excludeFolder : [excludeFolder];
-
-    const items = await readdir(dirPath);
-
-    for (const item of items) {
-        if (excludes.includes(item)) continue; // pula as pastas excluídas
-
-        const itemPath = path.join(dirPath, item);
-        const info = await stat(itemPath);
-
-        await rm(itemPath, { recursive: info.isDirectory(), force: true });
-    }
-}
-module.exports = { build, watch, buildWithChunks, watchWithChunks };