hightjs 0.1.1

package/dist/auth/routes.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAuthRoutes = createAuthRoutes;
+const http_1 = require("../api/http");
+const core_1 = require("./core");
+/**
+ * Cria o handler catch-all para /api/auth/[...value]
+ */
+function createAuthRoutes(config) {
+    const auth = new core_1.HWebAuth(config);
+    /**
+     * Handler principal que gerencia todas as rotas de auth
+     * Uso: /api/auth/[...value].ts
+     */
+    return {
+        pattern: '/api/auth/[value]',
+        async GET(req, params) {
+            const path = params["value"];
+            const route = Array.isArray(path) ? path.join('/') : path || '';
+            switch (route) {
+                case 'session':
+                    return await handleSession(req, auth);
+                case 'csrf':
+                    return await handleCsrf(req);
+                case 'providers':
+                    return await handleProviders(config);
+                default:
+                    return http_1.HightJSResponse.json({ error: 'Route not found' }, { status: 404 });
+            }
+        },
+        async POST(req, params) {
+            const path = params["value"];
+            const route = Array.isArray(path) ? path.join('/') : path || '';
+            switch (route) {
+                case 'signin':
+                    return await handleSignIn(req, auth);
+                case 'signout':
+                    return await handleSignOut(req, auth);
+                default:
+                    return http_1.HightJSResponse.json({ error: 'Route not found' }, { status: 404 });
+            }
+        },
+        // Instância do auth para uso manual
+        auth
+    };
+}
+/**
+ * Handler para GET /api/auth/session
+ */
+async function handleSession(req, auth) {
+    const session = await auth.getSession(req);
+    if (!session) {
+        return http_1.HightJSResponse.json({ session: null });
+    }
+    return http_1.HightJSResponse.json({ session });
+}
+/**
+ * Handler para GET /api/auth/csrf
+ */
+async function handleCsrf(req) {
+    // Token CSRF simples para proteção
+    const csrfToken = Math.random().toString(36).substring(2, 15) +
+        Math.random().toString(36).substring(2, 15);
+    return http_1.HightJSResponse.json({ csrfToken });
+}
+/**
+ * Handler para GET /api/auth/providers
+ */
+async function handleProviders(config) {
+    const providers = config.providers
+        .filter(p => p.type === 'credentials') // Apenas credentials
+        .map(p => ({
+        id: p.id,
+        name: p.name,
+        type: p.type
+    }));
+    return http_1.HightJSResponse.json({ providers });
+}
+/**
+ * Handler para POST /api/auth/signin
+ */
+async function handleSignIn(req, auth) {
+    try {
+        const { provider = 'credentials', ...credentials } = await req.json();
+        // Apenas credentials agora
+        const result = await auth.signIn(provider, credentials);
+        if (!result) {
+            return http_1.HightJSResponse.json({ error: 'Invalid credentials' }, { status: 401 });
+        }
+        return auth.createAuthResponse(result.token, {
+            success: true,
+            user: result.session.user
+        });
+    }
+    catch (error) {
+        return http_1.HightJSResponse.json({ error: 'Authentication failed' }, { status: 500 });
+    }
+}
+/**
+ * Handler para POST /api/auth/signout
+ */
+async function handleSignOut(req, auth) {
+    return auth.signOut();
+}

package/dist/auth/types.d.ts

@@ -0,0 +1,62 @@
+export type User = Record<string, any>;
+export interface Session {
+    user: User;
+    expires: string;
+    accessToken?: string;
+}
+export interface AuthConfig {
+    providers: AuthProvider[];
+    pages?: {
+        signIn?: string;
+        signOut?: string;
+        error?: string;
+    };
+    callbacks?: {
+        signIn?: (user: User, account: any, profile: any) => boolean | Promise<boolean>;
+        session?: (session: Session, user: User) => Session | Promise<Session>;
+        jwt?: (token: any, user: User, account: any, profile: any) => any | Promise<any>;
+    };
+    session?: {
+        strategy?: 'jwt' | 'database';
+        maxAge?: number;
+        updateAge?: number;
+    };
+    secret?: string;
+    debug?: boolean;
+}
+export interface AuthProvider {
+    id: string;
+    name: string;
+    type: 'credentials';
+    authorize?: (credentials: Record<string, string>) => Promise<User | null> | User | null;
+}
+export interface SignInOptions {
+    redirect?: boolean;
+    callbackUrl?: string;
+    [key: string]: any;
+}
+export interface SignInResult {
+    error?: string;
+    status?: number;
+    ok?: boolean;
+    url?: string;
+}
+export interface SessionContextType {
+    data: Session | null;
+    status: 'loading' | 'authenticated' | 'unauthenticated';
+    signIn: (provider?: string, options?: SignInOptions) => Promise<SignInResult | undefined>;
+    signOut: (options?: {
+        callbackUrl?: string;
+    }) => Promise<void>;
+    update: () => Promise<Session | null>;
+}
+export interface CredentialsConfig {
+    id?: string;
+    name?: string;
+    credentials: Record<string, {
+        label: string;
+        type: string;
+        placeholder?: string;
+    }>;
+    authorize: (credentials: Record<string, string>) => Promise<User | null> | User | null;
+}

package/dist/auth/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/bin/hightjs.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/hightjs.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+"use strict";
+// Registra o ts-node para que o Node.js entenda TypeScript/TSX
+require('ts-node').register();
+const { program } = require('commander');
+const teste = require("../helpers");
+program
+    .version('1.0.0')
+    .description('CLI para gerenciar a aplicação.');
+// --- Comando DEV ---
+program
+    .command('dev')
+    .description('Inicia a aplicação em modo de desenvolvimento.')
+    .option('-p, --port <number>', 'Especifica a porta para rodar', '3000')
+    .option('-H, --hostname <string>', 'Especifica o hostname para rodar', '0.0.0.0')
+    .option('-f, --framework <string>', 'Especifica o framework a ser usado (native/express/fastify)', 'native')
+    .action((options) => {
+    const teste = require("../helpers");
+    const t = teste.default({ dev: true, port: options.port, hostname: options.hostname, framework: options.framework });
+    t.init();
+});
+// --- Comando START (Produção) ---
+program
+    .command('start')
+    .description('Inicia a aplicação em modo produção.')
+    .option('-p, --port <number>', 'Especifica a porta para rodar', '3000')
+    .option('-H, --hostname <string>', 'Especifica o hostname para rodar', '0.0.0.0')
+    .option('-f, --framework <string>', 'Especifica o framework a ser usado (native/express/fastify)', 'native')
+    .action((options) => {
+    const teste = require("../helpers");
+    const t = teste.default({ dev: false, port: options.port, hostname: options.hostname, framework: options.framework });
+    t.init();
+});
+// Faz o "parse" dos argumentos passados na linha de comando
+program.parse(process.argv);

package/dist/builder.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 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>}
+ */
+export function build(entryPoint: string, outfile: string, isProduction?: boolean): Promise<void>;
+/**
+ * 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>}
+ */
+export function watch(entryPoint: string, outfile: string, hotReloadManager?: Object): Promise<void>;
+/**
+ * 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>}
+ */
+export function buildWithChunks(entryPoint: string, outdir: string, isProduction?: boolean): Promise<void>;
+/**
+ * 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>}
+ */
+export function watchWithChunks(entryPoint: string, outdir: string, hotReloadManager?: Object): Promise<void>;

package/dist/builder.js

@@ -0,0 +1,341 @@
+"use strict";
+const esbuild = require('esbuild');
+const path = require('path');
+const Console = require("./api/console");
+// 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(`Não foi possível carregar 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(`Erro ao processar CSS com PostCSS:`, postcssError.message);
+                        Console.warn(`Usando CSS original sem processamento.`);
+                    }
+                }
+                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
+            };
+        });
+    }
+};
+/**
+ * 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) {
+    if (!isProduction) {
+        console.log(`Iniciando o build com chunks de \"${entryPoint}\"...`);
+    }
+    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,
+        });
+        if (!isProduction) {
+            console.log(`Build com chunks finalizado! Saída: \"${outdir}\".`);
+        }
+    }
+    catch (error) {
+        console.error('Ocorreu um erro durante o build com chunks:', 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) {
+    try {
+        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],
+            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('Erro ao iniciar o modo watch com 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) {
+    if (!isProduction) {
+        console.log(`Iniciando o build de \"${entryPoint}\"...`);
+    }
+    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
+        });
+        if (!isProduction) {
+            console.log(`Build finalizado com sucesso! Saída: \"${outfile}\".`);
+        }
+    }
+    catch (error) {
+        console.error('Ocorreu um erro durante o 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 {
+        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],
+            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('Erro ao iniciar o modo watch:', error);
+        throw error;
+    }
+}
+module.exports = { build, watch, buildWithChunks, watchWithChunks };

package/dist/client/DefaultNotFound.d.ts

@@ -0,0 +1 @@
+export default function DefaultNotFound(): import("react/jsx-runtime").JSX.Element;

package/dist/client/DefaultNotFound.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = DefaultNotFound;
+const jsx_runtime_1 = require("react/jsx-runtime");
+function DefaultNotFound() {
+    return ((0, jsx_runtime_1.jsx)("div", { style: {
+            fontFamily: 'system-ui, "Segoe UI", Roboto, Helvetica, Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji"',
+            height: '100vh',
+            textAlign: 'center',
+            display: 'flex',
+            flexDirection: 'column',
+            alignItems: 'center',
+            justifyContent: 'center'
+        }, children: (0, jsx_runtime_1.jsxs)("div", { children: [(0, jsx_runtime_1.jsx)("style", { dangerouslySetInnerHTML: {
+                        __html: `
+                        body {
+    color: #000;
+    /* Alterado de cor sólida para gradiente */
+    background: linear-gradient(to bottom, #e9e9e9, #ffffff);
+    margin: 0;
+}
+
+.next-error-h1 {
+    border-right: 1px solid rgba(0, 0, 0, .3);
+}
+
+@media (prefers-color-scheme: dark) {
+    body {
+        color: #fff;
+        /* Alterado de cor sólida para gradiente escuro */
+        background: linear-gradient(to bottom, #222, #000);
+    }
+
+    .next-error-h1 {
+        border-right: 1px solid rgba(255, 255, 255, .3);
+    }
+}
+                    `
+                    } }), (0, jsx_runtime_1.jsx)("h1", { className: "next-error-h1", style: {
+                        display: 'inline-block',
+                        margin: '0px 20px 0px 0px',
+                        padding: '0px 23px 0px 0px',
+                        fontSize: '24px',
+                        fontWeight: '500',
+                        verticalAlign: 'top',
+                        lineHeight: '49px'
+                    }, children: "404" }), (0, jsx_runtime_1.jsx)("div", { style: { display: 'inline-block' }, children: (0, jsx_runtime_1.jsx)("h2", { style: {
+                            fontSize: '14px',
+                            fontWeight: '400',
+                            lineHeight: '49px',
+                            margin: '0px'
+                        }, children: "Esta p\u00E1gina n\u00E3o pode ser achada." }) })] }) }));
+}

package/dist/client/ErrorBoundary.d.ts

@@ -0,0 +1,16 @@
+import React, { Component, ErrorInfo, ReactNode } from 'react';
+interface Props {
+    children: ReactNode;
+}
+interface State {
+    hasError: boolean;
+    error?: Error;
+    errorInfo?: ErrorInfo;
+}
+export declare class ErrorBoundary extends Component<Props, State> {
+    constructor(props: Props);
+    static getDerivedStateFromError(error: Error): State;
+    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+    render(): string | number | boolean | Iterable<React.ReactNode> | import("react/jsx-runtime").JSX.Element | null | undefined;
+}
+export {};