hightjs 0.1.1

package/dist/client/routerContext.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RouterProvider = RouterProvider;
+exports.useRouter = useRouter;
+exports.usePathname = usePathname;
+exports.useSearchParams = useSearchParams;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const react_1 = require("react");
+const clientRouter_1 = require("./clientRouter");
+const RouterContext = (0, react_1.createContext)(null);
+function RouterProvider({ children }) {
+    const [pathname, setPathname] = (0, react_1.useState)(clientRouter_1.router.pathname);
+    const [query, setQuery] = (0, react_1.useState)(clientRouter_1.router.query);
+    (0, react_1.useEffect)(() => {
+        const updateRoute = () => {
+            setPathname(clientRouter_1.router.pathname);
+            setQuery(clientRouter_1.router.query);
+        };
+        // Subscribe to router changes
+        const unsubscribe = clientRouter_1.router.subscribe(updateRoute);
+        // Also listen to browser back/forward
+        window.addEventListener('popstate', updateRoute);
+        return () => {
+            unsubscribe();
+            window.removeEventListener('popstate', updateRoute);
+        };
+    }, []);
+    const value = {
+        pathname,
+        query,
+        push: clientRouter_1.router.push.bind(clientRouter_1.router),
+        replace: clientRouter_1.router.replace.bind(clientRouter_1.router),
+        back: clientRouter_1.router.back.bind(clientRouter_1.router),
+        forward: clientRouter_1.router.forward.bind(clientRouter_1.router),
+        refresh: clientRouter_1.router.refresh.bind(clientRouter_1.router),
+    };
+    return ((0, jsx_runtime_1.jsx)(RouterContext.Provider, { value: value, children: children }));
+}
+/**
+ * Hook para acessar o router dentro de componentes React
+ */
+function useRouter() {
+    const context = (0, react_1.useContext)(RouterContext);
+    if (!context) {
+        throw new Error('useRouter deve ser usado dentro de um RouterProvider');
+    }
+    return context;
+}
+/**
+ * Hook para acessar apenas o pathname atual
+ */
+function usePathname() {
+    const { pathname } = useRouter();
+    return pathname;
+}
+/**
+ * Hook para acessar apenas os query parameters
+ */
+function useSearchParams() {
+    const { query } = useRouter();
+    return query;
+}

package/dist/client.d.ts

@@ -0,0 +1,3 @@
+export { Link } from './components/Link';
+export { RouteConfig, Metadata } from "./types";
+export { router } from './client/clientRouter';

package/dist/client.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.router = exports.Link = void 0;
+// Este arquivo exporta apenas código seguro para o cliente (navegador)
+var Link_1 = require("./components/Link");
+Object.defineProperty(exports, "Link", { enumerable: true, get: function () { return Link_1.Link; } });
+var clientRouter_1 = require("./client/clientRouter");
+Object.defineProperty(exports, "router", { enumerable: true, get: function () { return clientRouter_1.router; } });

package/dist/components/Link.d.ts

@@ -0,0 +1,7 @@
+import { type AnchorHTMLAttributes, type ReactNode } from 'react';
+interface LinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
+    href: string;
+    children: ReactNode;
+}
+export declare function Link({ href, children, ...props }: LinkProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/Link.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Link = Link;
+const jsx_runtime_1 = require("react/jsx-runtime");
+const clientRouter_1 = require("../client/clientRouter");
+function Link({ href, children, ...props }) {
+    const handleClick = async (e) => {
+        e.preventDefault();
+        // Usa o novo sistema de router
+        await clientRouter_1.router.push(href);
+    };
+    return ((0, jsx_runtime_1.jsx)("a", { href: href, ...props, onClick: handleClick, children: children }));
+}

package/dist/eslint/index.d.ts

@@ -0,0 +1,32 @@
+export let rules: {
+    'require-use-client': {
+        meta: {
+            type: string;
+            docs: {
+                description: string;
+                category: string;
+                recommended: boolean;
+            };
+            fixable: string;
+            schema: never[];
+            messages: {
+                missingUseClient: string;
+            };
+        };
+        create(context: any): {
+            Program(node: any): void;
+            ImportDeclaration(node: any): void;
+            CallExpression(node: any): void;
+            'Program:exit'(): void;
+        };
+    };
+};
+export namespace configs {
+    namespace recommended {
+        export let plugins: string[];
+        let rules_1: {
+            'hightjs/require-use-client': string;
+        };
+        export { rules_1 as rules };
+    }
+}

package/dist/eslint/index.js

@@ -0,0 +1,15 @@
+"use strict";
+const useClientRule = require('./use-client-rule');
+module.exports = {
+    rules: {
+        'require-use-client': useClientRule,
+    },
+    configs: {
+        recommended: {
+            plugins: ['hightjs'],
+            rules: {
+                'hightjs/require-use-client': 'error',
+            },
+        },
+    },
+};

package/dist/eslint/use-client-rule.d.ts

@@ -0,0 +1,19 @@
+export namespace meta {
+    let type: string;
+    namespace docs {
+        let description: string;
+        let category: string;
+        let recommended: boolean;
+    }
+    let fixable: string;
+    let schema: never[];
+    namespace messages {
+        let missingUseClient: string;
+    }
+}
+export function create(context: any): {
+    Program(node: any): void;
+    ImportDeclaration(node: any): void;
+    CallExpression(node: any): void;
+    'Program:exit'(): void;
+};

package/dist/eslint/use-client-rule.js

@@ -0,0 +1,99 @@
+"use strict";
+/**
+ * ESLint rule: require-use-client
+ * Força o uso de "use client" quando React ou hooks são importados
+ */
+module.exports = {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Require "use client" directive when importing React or React hooks',
+            category: 'Best Practices',
+            recommended: true,
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            missingUseClient: 'Arquivos que importam React ou hooks devem começar com "use client"',
+        },
+    },
+    create(context) {
+        let hasReactImport = false;
+        let hasReactHooks = false;
+        let hasUseClient = false;
+        let firstNode = null;
+        // Lista de hooks do React que requerem "use client"
+        const reactHooks = [
+            'useState', 'useEffect', 'useContext', 'useReducer',
+            'useCallback', 'useMemo', 'useRef', 'useImperativeHandle',
+            'useLayoutEffect', 'useDebugValue', 'useDeferredValue',
+            'useTransition', 'useId', 'useSyncExternalStore',
+            'useInsertionEffect'
+        ];
+        return {
+            Program(node) {
+                firstNode = node;
+                // Verifica se já tem "use client" no início do arquivo
+                const sourceCode = context.getSourceCode();
+                const firstToken = sourceCode.getFirstToken(node);
+                if (firstToken && firstToken.type === 'String') {
+                    const value = firstToken.value;
+                    if (value === '"use client"' || value === "'use client'") {
+                        hasUseClient = true;
+                    }
+                }
+                // Também verifica comentários
+                const comments = sourceCode.getAllComments();
+                if (comments.length > 0) {
+                    const firstComment = comments[0];
+                    if (firstComment.value.trim() === 'use client') {
+                        hasUseClient = true;
+                    }
+                }
+            },
+            ImportDeclaration(node) {
+                const source = node.source.value;
+                // Verifica se importa do React
+                if (source === 'react' || source === 'react/jsx-runtime') {
+                    hasReactImport = true;
+                    // Verifica se importa hooks específicos
+                    if (node.specifiers) {
+                        for (const specifier of node.specifiers) {
+                            if (specifier.type === 'ImportSpecifier' &&
+                                reactHooks.includes(specifier.imported.name)) {
+                                hasReactHooks = true;
+                                break;
+                            }
+                        }
+                    }
+                }
+            },
+            CallExpression(node) {
+                // Verifica se usa hooks do React diretamente
+                if (node.callee.type === 'Identifier' &&
+                    reactHooks.includes(node.callee.name)) {
+                    hasReactHooks = true;
+                }
+                // Verifica se usa React.useState, React.useEffect, etc.
+                if (node.callee.type === 'MemberExpression' &&
+                    node.callee.object.name === 'React' &&
+                    reactHooks.includes(node.callee.property.name)) {
+                    hasReactHooks = true;
+                }
+            },
+            'Program:exit'() {
+                // Se importa React ou usa hooks mas não tem "use client"
+                if ((hasReactImport || hasReactHooks) && !hasUseClient) {
+                    context.report({
+                        node: firstNode,
+                        messageId: 'missingUseClient',
+                        fix(fixer) {
+                            // Auto-fix: adiciona "use client" no início do arquivo
+                            return fixer.insertTextBefore(firstNode, '"use client";\n\n');
+                        }
+                    });
+                }
+            }
+        };
+    },
+};

package/dist/eslintSetup.js

@@ -0,0 +1 @@
+"use strict";

package/dist/example/src/web/routes/index.d.ts

@@ -0,0 +1,3 @@
+import { RouteConfig } from "../../../../client";
+export declare const config: RouteConfig;
+export default config;

package/dist/example/src/web/routes/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+const jsx_runtime_1 = require("react/jsx-runtime");
+function Home() {
+    return ((0, jsx_runtime_1.jsx)("h1", { children: "OL\u00C1 MUNDINHO MEU AMIGUINHO, VAMOS TRANSA?" }));
+}
+exports.config = {
+    pattern: '/',
+    component: Home,
+    generateMetadata: () => ({
+        title: 'HightJS | Home'
+    })
+};
+exports.default = exports.config;

package/dist/helpers.d.ts

@@ -0,0 +1,18 @@
+import type { HightJSOptions } from './types';
+export default app;
+export declare function app(options?: HightJSOptions): {
+    /**
+     * Integra com uma aplicação de qualquer framework (Express, Fastify, etc)
+     */
+    integrate: (serverApp: any) => Promise<any>;
+    /**
+     * Inicia um servidor HightJS fechado (o usuário não tem acesso ao framework)
+     */
+    init: () => Promise<any>;
+    prepare: () => Promise<void>;
+    executeInstrumentation: () => void;
+    getRequestHandler: () => import("./types").RequestHandler;
+    setupWebSocket: (server: any) => void;
+    build: () => Promise<void>;
+    stop: () => void;
+};

package/dist/helpers.js

@@ -0,0 +1,318 @@
+"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.app = app;
+// Helpers para integração com diferentes frameworks
+const index_1 = __importStar(require("./index"));
+const os_1 = __importDefault(require("os"));
+const console_1 = __importStar(require("./api/console"));
+function getLocalExternalIp() {
+    const interfaces = os_1.default.networkInterfaces();
+    for (const name of Object.keys(interfaces)) {
+        for (const iface of interfaces[name]) {
+            if (iface.family === 'IPv4' && !iface.internal) {
+                return iface.address;
+            }
+        }
+    }
+    return 'localhost';
+}
+const sendBox = (options) => {
+    const isDev = options.dev ? "Rodando em modo de desenvolvimento" : null;
+    const messages = [
+        ` ${console_1.Colors.FgMagenta}●  ${console_1.Colors.Reset}Local: ${console_1.Colors.FgGreen}http://localhost:${options.port}${console_1.Colors.Reset}`,
+        ` ${console_1.Colors.FgMagenta}●  ${console_1.Colors.Reset}Rede: ${console_1.Colors.FgGreen}http://${getLocalExternalIp()}:${options.port}${console_1.Colors.Reset}`,
+    ];
+    if (isDev) {
+        messages.push(` ${console_1.Colors.FgMagenta}●  ${console_1.Colors.Reset}${isDev}`);
+    }
+    console_1.default.box(messages.join("\n"), { title: "Acesse o HightJS em:" });
+};
+exports.default = app;
+function app(options = {}) {
+    const framework = options.framework || 'native'; // Mudando o padrão para 'native'
+    index_1.FrameworkAdapterFactory.setFramework(framework);
+    const hwebApp = (0, index_1.default)(options);
+    return {
+        ...hwebApp,
+        /**
+         * Integra com uma aplicação de qualquer framework (Express, Fastify, etc)
+         */
+        integrate: async (serverApp) => {
+            await hwebApp.prepare();
+            const handler = hwebApp.getRequestHandler();
+            if (framework === 'express') {
+                // Express integration
+                serverApp.use(handler);
+                hwebApp.setupWebSocket(serverApp);
+            }
+            else if (framework === 'fastify') {
+                // Fastify integration
+                await serverApp.register(async (fastify) => {
+                    fastify.all('*', handler);
+                });
+                hwebApp.setupWebSocket(serverApp);
+            }
+            else {
+                // Generic integration - assume Express-like
+                serverApp.use(handler);
+                hwebApp.setupWebSocket(serverApp);
+            }
+            hwebApp.executeInstrumentation();
+            return serverApp;
+        },
+        /**
+         * Inicia um servidor HightJS fechado (o usuário não tem acesso ao framework)
+         */
+        init: async () => {
+            console.log(`${console_1.Colors.FgMagenta}
+     _    _ _       _     _          _  _____ 
+    | |  | (_)     | |   | |        | |/ ____|
+    | |__| |_  __ _| |__ | |_       | | (___  
+    |  __  | |/ _\` | '_ \\| __|  _   | |\\___ \\ 
+    | |  | | | (_| | | | | |_  | |__| |____) |
+    |_|  |_|_|\\__, |_| |_|\\__|  \\____/|_____/ 
+               __/ |                          
+              |___/                           ${console_1.Colors.Reset}`);
+            const actualPort = options.port || 3000;
+            const actualHostname = options.hostname || "0.0.0.0";
+            if (framework === 'express') {
+                return await initExpressServer(hwebApp, options, actualPort, actualHostname);
+            }
+            else if (framework === 'fastify') {
+                return await initFastifyServer(hwebApp, options, actualPort, actualHostname);
+            }
+            else {
+                // Default to Native
+                return await initNativeServer(hwebApp, options, actualPort, actualHostname);
+            }
+        }
+    };
+}
+/**
+ * Inicializa servidor Express fechado
+ */
+async function initExpressServer(hwebApp, options, port, hostname) {
+    const msg = console_1.default.dynamicLine(`  ${console_1.Colors.FgCyan}●  ${console_1.Colors.Reset}Iniciando HightJS com Express...`);
+    const express = require('express');
+    const app = express();
+    // Middlewares básicos para Express
+    app.use(express.json());
+    app.use(express.urlencoded({ extended: true }));
+    // Cookie parser se disponível
+    try {
+        const cookieParser = require('cookie-parser');
+        app.use(cookieParser());
+    }
+    catch (e) {
+        console_1.default.error("Não foi possivel achar cookie-parser");
+    }
+    await hwebApp.prepare();
+    const handler = hwebApp.getRequestHandler();
+    app.use(handler);
+    const server = app.listen(port, hostname, () => {
+        sendBox({ ...options, port });
+        msg.end(`  ${console_1.Colors.FgCyan}●  ${console_1.Colors.Reset}Servidor Express iniciado (compatibilidade)`);
+    });
+    // Configura WebSocket para hot reload
+    hwebApp.setupWebSocket(server);
+    hwebApp.executeInstrumentation();
+    return server;
+}
+/**
+ * Inicializa servidor Fastify fechado
+ */
+async function initFastifyServer(hwebApp, options, port, hostname) {
+    const msg = console_1.default.dynamicLine(`  ${console_1.Colors.FgCyan}●  ${console_1.Colors.Reset}Iniciando HightJS com Fastify...`);
+    const fastify = require('fastify')({ logger: false });
+    // Registra plugins básicos para Fastify
+    try {
+        await fastify.register(require('@fastify/cookie'));
+    }
+    catch (e) {
+        console_1.default.error("Não foi possivel achar @fastify/cookie");
+    }
+    try {
+        await fastify.register(require('@fastify/formbody'));
+    }
+    catch (e) {
+        console_1.default.error("Não foi possivel achar @fastify/formbody");
+    }
+    await hwebApp.prepare();
+    const handler = hwebApp.getRequestHandler();
+    // Registra o handler do hweb
+    await fastify.register(async (fastify) => {
+        fastify.all('*', handler);
+    });
+    hwebApp.setupWebSocket(fastify);
+    const address = await fastify.listen({ port, host: hostname });
+    sendBox({ ...options, port });
+    msg.end(`  ${console_1.Colors.FgCyan}●  ${console_1.Colors.Reset}Servidor Fastify iniciado (compatibilidade)`);
+    hwebApp.executeInstrumentation();
+    return fastify;
+}
+/**
+ * Inicializa servidor nativo do HightJS usando HTTP puro
+ */
+async function initNativeServer(hwebApp, options, port, hostname) {
+    const msg = console_1.default.dynamicLine(`  ${console_1.Colors.FgMagenta}⚡  ${console_1.Colors.Reset}${console_1.Colors.Bright}Iniciando HightJS em modo NATIVO${console_1.Colors.Reset}`);
+    const http = require('http');
+    const { parse: parseUrl } = require('url');
+    const { parse: parseQuery } = require('querystring');
+    await hwebApp.prepare();
+    const handler = hwebApp.getRequestHandler();
+    // Middleware para parsing do body com proteções de segurança
+    const parseBody = (req) => {
+        return new Promise((resolve, reject) => {
+            if (req.method === 'GET' || req.method === 'HEAD') {
+                resolve(null);
+                return;
+            }
+            let body = '';
+            let totalSize = 0;
+            const maxBodySize = 10 * 1024 * 1024; // 10MB limite
+            // Timeout para requisições que demoram muito
+            const timeout = setTimeout(() => {
+                req.destroy();
+                reject(new Error('Request timeout'));
+            }, 30000); // 30 segundos
+            req.on('data', (chunk) => {
+                totalSize += chunk.length;
+                // Proteção contra ataques de DoS por body muito grande
+                if (totalSize > maxBodySize) {
+                    clearTimeout(timeout);
+                    req.destroy();
+                    reject(new Error('Request body too large'));
+                    return;
+                }
+                body += chunk.toString();
+            });
+            req.on('end', () => {
+                clearTimeout(timeout);
+                try {
+                    const contentType = req.headers['content-type'] || '';
+                    if (contentType.includes('application/json')) {
+                        // Validação adicional para JSON
+                        if (body.length > 1024 * 1024) { // 1MB limite para JSON
+                            reject(new Error('JSON body too large'));
+                            return;
+                        }
+                        resolve(JSON.parse(body));
+                    }
+                    else if (contentType.includes('application/x-www-form-urlencoded')) {
+                        resolve(parseQuery(body));
+                    }
+                    else {
+                        resolve(body);
+                    }
+                }
+                catch (error) {
+                    resolve(body); // Fallback para string se parsing falhar
+                }
+            });
+            req.on('error', (error) => {
+                clearTimeout(timeout);
+                reject(error);
+            });
+        });
+    };
+    // Cria o servidor HTTP nativo com configurações de segurança
+    const server = http.createServer(async (req, res) => {
+        // Configurações de segurança básicas
+        res.setHeader('X-Content-Type-Options', 'nosniff');
+        res.setHeader('X-Frame-Options', 'DENY');
+        res.setHeader('X-XSS-Protection', '1; mode=block');
+        res.setHeader('Referrer-Policy', 'strict-origin-when-cross-origin');
+        // Timeout para requisições
+        req.setTimeout(30000, () => {
+            res.statusCode = 408; // Request Timeout
+            res.end('Request timeout');
+        });
+        try {
+            // Validação básica de URL para prevenir ataques
+            const url = req.url || '/';
+            if (url.length > 2048) {
+                res.statusCode = 414; // URI Too Long
+                res.end('URL too long');
+                return;
+            }
+            // Parse do body com proteções
+            req.body = await parseBody(req);
+            // Adiciona host se não existir
+            req.headers.host = req.headers.host || `localhost:${port}`;
+            // Chama o handler do HightJS
+            await handler(req, res);
+        }
+        catch (error) {
+            console_1.default.error('Erro no servidor nativo:', error);
+            if (!res.headersSent) {
+                res.statusCode = 500;
+                res.setHeader('Content-Type', 'text/plain');
+                if (error instanceof Error) {
+                    if (error.message.includes('too large')) {
+                        res.statusCode = 413; // Payload Too Large
+                        res.end('Request too large');
+                    }
+                    else if (error.message.includes('timeout')) {
+                        res.statusCode = 408; // Request Timeout
+                        res.end('Request timeout');
+                    }
+                    else {
+                        res.end('Internal server error');
+                    }
+                }
+                else {
+                    res.end('Internal server error');
+                }
+            }
+        }
+    });
+    // Configurações de segurança do servidor
+    server.setTimeout(35000); // Timeout geral do servidor
+    server.maxHeadersCount = 100; // Limita número de headers
+    server.headersTimeout = 60000; // Timeout para headers
+    server.requestTimeout = 30000; // Timeout para requisições
+    server.listen(port, hostname, () => {
+        sendBox({ ...options, port });
+        msg.end(`  ${console_1.Colors.FgGreen}⚡  ${console_1.Colors.Reset}${console_1.Colors.Bright}Servidor HightJS NATIVO ativo!${console_1.Colors.Reset}`);
+    });
+    // Configura WebSocket para hot reload
+    hwebApp.setupWebSocket(server);
+    hwebApp.executeInstrumentation();
+    return server;
+}

package/dist/hotReload.d.ts

@@ -0,0 +1,23 @@
+import { IncomingMessage } from 'http';
+export declare class HotReloadManager {
+    private wss;
+    private watchers;
+    private projectDir;
+    private clients;
+    private pingInterval;
+    private backendApiChangeCallback;
+    private frontendChangeCallback;
+    constructor(projectDir: string);
+    start(): Promise<void>;
+    handleUpgrade(request: IncomingMessage, socket: any, head: Buffer): void;
+    private setupWebSocketServer;
+    private setupWatchers;
+    private notifyClients;
+    private restartServer;
+    stop(): void;
+    getClientScript(): string;
+    private clearBackendCache;
+    onBackendApiChange(callback: () => void): void;
+    onFrontendChange(callback: () => void): void;
+    private checkFrontendBuild;
+}