hightjs 0.1.1

package/dist/router.d.ts

@@ -0,0 +1,78 @@
+import { RouteConfig, BackendRouteConfig } from './types';
+/**
+ * Limpa todo o cache de rotas carregadas
+ */
+export declare function clearAllRouteCache(): void;
+/**
+ * Limpa o cache de um arquivo específico e recarrega as rotas se necessário
+ * @param changedFilePath Caminho do arquivo que foi alterado
+ */
+export declare function clearFileCache(changedFilePath: string): void;
+/**
+ * Carrega o layout.tsx se existir no diretório web
+ * @param webDir O diretório web onde procurar o layout
+ * @returns O layout carregado ou null se não existir
+ */
+export declare function loadLayout(webDir: string): {
+    componentPath: string;
+    metadata?: any;
+} | null;
+/**
+ * Retorna o layout atual se carregado
+ */
+export declare function getLayout(): {
+    componentPath: string;
+    metadata?: any;
+} | null;
+/**
+ * Carrega dinamicamente todas as rotas de frontend do diretório do usuário.
+ * @param routesDir O diretório onde as rotas de página estão localizadas.
+ * @returns A lista de rotas de página que foram carregadas.
+ */
+export declare function loadRoutes(routesDir: string): (RouteConfig & {
+    componentPath: string;
+})[];
+/**
+ * Encontra a rota de página correspondente para uma URL.
+ * @param pathname O caminho da URL (ex: "/users/123").
+ * @returns Um objeto com a rota e os parâmetros, ou null se não encontrar.
+ */
+export declare function findMatchingRoute(pathname: string): {
+    route: RouteConfig & {
+        componentPath: string;
+    };
+    params: {
+        [key: string]: string;
+    };
+} | null;
+/**
+ * Carrega dinamicamente todas as rotas de API do diretório de backend.
+ * @param backendRoutesDir O diretório onde as rotas de API estão localizadas.
+ */
+export declare function loadBackendRoutes(backendRoutesDir: string): void;
+/**
+ * Encontra a rota de API correspondente para uma URL e método HTTP.
+ * @param pathname O caminho da URL (ex: "/api/users/123").
+ * @param method O método HTTP da requisição (GET, POST, etc.).
+ * @returns Um objeto com a rota e os parâmetros, ou null se não encontrar.
+ */
+export declare function findMatchingBackendRoute(pathname: string, method: string): {
+    route: BackendRouteConfig;
+    params: {
+        [key: string]: string;
+    };
+} | null;
+/**
+ * Carrega o notFound.tsx se existir no diretório web
+ * @param webDir O diretório web onde procurar o notFound
+ * @returns O notFound carregado ou null se não existir
+ */
+export declare function loadNotFound(webDir: string): {
+    componentPath: string;
+} | null;
+/**
+ * Retorna o componente 404 atual se carregado
+ */
+export declare function getNotFound(): {
+    componentPath: string;
+} | null;

package/dist/router.js

@@ -0,0 +1,359 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clearAllRouteCache = clearAllRouteCache;
+exports.clearFileCache = clearFileCache;
+exports.loadLayout = loadLayout;
+exports.getLayout = getLayout;
+exports.loadRoutes = loadRoutes;
+exports.findMatchingRoute = findMatchingRoute;
+exports.loadBackendRoutes = loadBackendRoutes;
+exports.findMatchingBackendRoute = findMatchingBackendRoute;
+exports.loadNotFound = loadNotFound;
+exports.getNotFound = getNotFound;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const console_1 = __importDefault(require("./api/console"));
+// --- Roteamento do Frontend ---
+// Guarda todas as rotas de PÁGINA (React) encontradas
+// A rota agora também armazena o caminho do arquivo para ser usado como um ID único no cliente
+let allRoutes = [];
+// Guarda o layout se existir
+let layoutComponent = null;
+// Guarda o componente 404 personalizado se existir
+let notFoundComponent = null;
+// Cache de arquivos carregados para limpeza
+let loadedRouteFiles = new Set();
+let loadedLayoutFiles = new Set();
+let loadedNotFoundFiles = new Set();
+/**
+ * Limpa o cache do require para um arquivo específico
+ * @param filePath Caminho do arquivo para limpar
+ */
+function clearRequireCache(filePath) {
+    try {
+        const resolvedPath = require.resolve(filePath);
+        delete require.cache[resolvedPath];
+        // Também limpa arquivos temporários relacionados
+        const tempFile = filePath.replace(/\.(tsx|ts)$/, '.temp.$1');
+        try {
+            const tempResolvedPath = require.resolve(tempFile);
+            delete require.cache[tempResolvedPath];
+        }
+        catch {
+            // Arquivo temporário pode não existir
+        }
+    }
+    catch (error) {
+        // Arquivo pode não estar no cache
+    }
+}
+/**
+ * Limpa todo o cache de rotas carregadas
+ */
+function clearAllRouteCache() {
+    // Limpa cache das rotas
+    loadedRouteFiles.forEach(filePath => {
+        clearRequireCache(filePath);
+    });
+    loadedRouteFiles.clear();
+    // Limpa cache do layout
+    loadedLayoutFiles.forEach(filePath => {
+        clearRequireCache(filePath);
+    });
+    loadedLayoutFiles.clear();
+    // Limpa cache do notFound
+    loadedNotFoundFiles.forEach(filePath => {
+        clearRequireCache(filePath);
+    });
+    loadedNotFoundFiles.clear();
+}
+/**
+ * Limpa o cache de um arquivo específico e recarrega as rotas se necessário
+ * @param changedFilePath Caminho do arquivo que foi alterado
+ */
+function clearFileCache(changedFilePath) {
+    const absolutePath = path_1.default.isAbsolute(changedFilePath) ? changedFilePath : path_1.default.resolve(changedFilePath);
+    // Limpa o cache do arquivo específico
+    clearRequireCache(absolutePath);
+    // Remove das listas de arquivos carregados
+    loadedRouteFiles.delete(absolutePath);
+    loadedLayoutFiles.delete(absolutePath);
+    loadedNotFoundFiles.delete(absolutePath);
+}
+/**
+ * Carrega o layout.tsx se existir no diretório web
+ * @param webDir O diretório web onde procurar o layout
+ * @returns O layout carregado ou null se não existir
+ */
+function loadLayout(webDir) {
+    const layoutPath = path_1.default.join(webDir, 'layout.tsx');
+    const layoutPathJs = path_1.default.join(webDir, 'layout.ts');
+    const layoutFile = fs_1.default.existsSync(layoutPath) ? layoutPath :
+        fs_1.default.existsSync(layoutPathJs) ? layoutPathJs : null;
+    if (layoutFile) {
+        const componentPath = path_1.default.relative(process.cwd(), layoutFile).replace(/\\/g, '/');
+        const absolutePath = path_1.default.resolve(layoutFile);
+        try {
+            // Limpa o cache antes de recarregar
+            clearRequireCache(absolutePath);
+            // HACK: Cria uma versão temporária do layout SEM imports de CSS para carregar no servidor
+            const layoutContent = fs_1.default.readFileSync(layoutFile, 'utf8');
+            const tempContent = layoutContent
+                .replace(/import\s+['"][^'"]*\.css['"];?/g, '// CSS import removido para servidor')
+                .replace(/import\s+['"][^'"]*\.scss['"];?/g, '// SCSS import removido para servidor')
+                .replace(/import\s+['"][^'"]*\.sass['"];?/g, '// SASS import removido para servidor');
+            const tempFile = layoutFile.replace(/\.(tsx|ts)$/, '.temp.$1');
+            fs_1.default.writeFileSync(tempFile, tempContent);
+            // Carrega o arquivo temporário sem CSS
+            delete require.cache[require.resolve(tempFile)];
+            const layoutModule = require(tempFile);
+            // Remove o arquivo temporário
+            fs_1.default.unlinkSync(tempFile);
+            const metadata = layoutModule.metadata || null;
+            // Registra o arquivo como carregado
+            loadedLayoutFiles.add(absolutePath);
+            layoutComponent = { componentPath, metadata };
+            return layoutComponent;
+        }
+        catch (error) {
+            console_1.default.error(`Erro ao carregar layout ${layoutFile}:`, error);
+            layoutComponent = { componentPath };
+            return layoutComponent;
+        }
+    }
+    layoutComponent = null;
+    return null;
+}
+/**
+ * Retorna o layout atual se carregado
+ */
+function getLayout() {
+    return layoutComponent;
+}
+/**
+ * Carrega dinamicamente todas as rotas de frontend do diretório do usuário.
+ * @param routesDir O diretório onde as rotas de página estão localizadas.
+ * @returns A lista de rotas de página que foram carregadas.
+ */
+function loadRoutes(routesDir) {
+    if (!fs_1.default.existsSync(routesDir)) {
+        console_1.default.warn(`Diretório de rotas de frontend não encontrado em ${routesDir}. Nenhuma página será carregada.`);
+        allRoutes = [];
+        return allRoutes;
+    }
+    const files = fs_1.default.readdirSync(routesDir, { recursive: true, encoding: 'utf-8' });
+    // Corrigindo o filtro para excluir corretamente o diretório backend
+    const routeFiles = files.filter(file => {
+        const isTypeScriptFile = file.endsWith('.ts') || file.endsWith('.tsx');
+        const isNotBackend = !file.includes('backend' + path_1.default.sep) && !file.includes('backend/');
+        return isTypeScriptFile && isNotBackend;
+    });
+    const loaded = [];
+    for (const file of routeFiles) {
+        const filePath = path_1.default.join(routesDir, file);
+        const absolutePath = path_1.default.resolve(filePath);
+        // Usamos um caminho relativo ao CWD como um ID estável para o componente.
+        const componentPath = path_1.default.relative(process.cwd(), filePath).replace(/\\/g, '/');
+        try {
+            // Limpa o cache antes de recarregar para pegar alterações nos metadados
+            clearRequireCache(absolutePath);
+            const routeModule = require(filePath);
+            if (routeModule.default && routeModule.default.pattern && routeModule.default.component) {
+                loaded.push({ ...routeModule.default, componentPath });
+                // Registra o arquivo como carregado
+                loadedRouteFiles.add(absolutePath);
+            }
+        }
+        catch (error) {
+            console_1.default.error(`Erro ao carregar a rota de página ${filePath}:`, error);
+        }
+    }
+    allRoutes = loaded;
+    return allRoutes;
+}
+/**
+ * Encontra a rota de página correspondente para uma URL.
+ * @param pathname O caminho da URL (ex: "/users/123").
+ * @returns Um objeto com a rota e os parâmetros, ou null se não encontrar.
+ */
+function findMatchingRoute(pathname) {
+    for (const route of allRoutes) {
+        if (!route.pattern)
+            continue;
+        // Converte o padrão da rota (ex: /users/[id]) em uma RegExp
+        const regexPattern = route.pattern.replace(/\[(\w+)\]/g, '(?<$1>[^/]+)');
+        const regex = new RegExp(`^${regexPattern}/?$`);
+        const match = pathname.match(regex);
+        if (match) {
+            return {
+                route,
+                params: match.groups || {}
+            };
+        }
+    }
+    return null;
+}
+// --- Roteamento do Backend ---
+// Guarda todas as rotas de API encontradas
+let allBackendRoutes = [];
+// Cache de middlewares carregados por diretório
+let loadedMiddlewares = new Map();
+/**
+ * Carrega middlewares de um diretório específico
+ * @param dir O diretório onde procurar por middleware.ts
+ * @returns Array de middlewares encontrados
+ */
+function loadMiddlewareFromDirectory(dir) {
+    const middlewares = [];
+    // Procura por middleware.ts ou middleware.tsx
+    const middlewarePath = path_1.default.join(dir, 'middleware.ts');
+    const middlewarePathTsx = path_1.default.join(dir, 'middleware.tsx');
+    const middlewareFile = fs_1.default.existsSync(middlewarePath) ? middlewarePath :
+        fs_1.default.existsSync(middlewarePathTsx) ? middlewarePathTsx : null;
+    if (middlewareFile) {
+        try {
+            const absolutePath = path_1.default.resolve(middlewareFile);
+            clearRequireCache(absolutePath);
+            const middlewareModule = require(middlewareFile);
+            // Suporte para export default (função única) ou export { middleware1, middleware2 }
+            if (typeof middlewareModule.default === 'function') {
+                middlewares.push(middlewareModule.default);
+            }
+            else if (middlewareModule.default && Array.isArray(middlewareModule.default)) {
+                middlewares.push(...middlewareModule.default);
+            }
+            else {
+                // Procura por exports nomeados que sejam funções
+                Object.keys(middlewareModule).forEach(key => {
+                    if (key !== 'default' && typeof middlewareModule[key] === 'function') {
+                        middlewares.push(middlewareModule[key]);
+                    }
+                });
+            }
+        }
+        catch (error) {
+            console_1.default.error(`Erro ao carregar middleware ${middlewareFile}:`, error);
+        }
+    }
+    return middlewares;
+}
+/**
+ * Coleta middlewares do diretório específico da rota (não herda dos pais)
+ * @param routeFilePath Caminho completo do arquivo de rota
+ * @param backendRoutesDir Diretório raiz das rotas de backend
+ * @returns Array com middlewares apenas do diretório da rota
+ */
+function collectMiddlewaresForRoute(routeFilePath, backendRoutesDir) {
+    const relativePath = path_1.default.relative(backendRoutesDir, routeFilePath);
+    const routeDir = path_1.default.dirname(path_1.default.join(backendRoutesDir, relativePath));
+    // Carrega middlewares APENAS do diretório específico da rota (não herda dos pais)
+    if (!loadedMiddlewares.has(routeDir)) {
+        const middlewares = loadMiddlewareFromDirectory(routeDir);
+        loadedMiddlewares.set(routeDir, middlewares);
+    }
+    return loadedMiddlewares.get(routeDir) || [];
+}
+/**
+ * Carrega dinamicamente todas as rotas de API do diretório de backend.
+ * @param backendRoutesDir O diretório onde as rotas de API estão localizadas.
+ */
+function loadBackendRoutes(backendRoutesDir) {
+    if (!fs_1.default.existsSync(backendRoutesDir)) {
+        // É opcional ter uma API, então não mostramos um aviso se a pasta não existir.
+        allBackendRoutes = [];
+        return;
+    }
+    // Limpa cache de middlewares para recarregar
+    loadedMiddlewares.clear();
+    const files = fs_1.default.readdirSync(backendRoutesDir, { recursive: true, encoding: 'utf-8' });
+    const routeFiles = files.filter(file => {
+        const isTypeScript = file.endsWith('.ts') || file.endsWith('.tsx');
+        const isNotMiddleware = !path_1.default.basename(file).startsWith('middleware');
+        return isTypeScript && isNotMiddleware;
+    });
+    const loaded = [];
+    for (const file of routeFiles) {
+        const filePath = path_1.default.join(backendRoutesDir, file);
+        try {
+            const routeModule = require(filePath);
+            if (routeModule.default && routeModule.default.pattern) {
+                const routeConfig = { ...routeModule.default };
+                // Se a rota NÃO tem a propriedade middleware definida, carrega os da pasta
+                if (!routeConfig.hasOwnProperty('middleware')) {
+                    const folderMiddlewares = collectMiddlewaresForRoute(filePath, backendRoutesDir);
+                    if (folderMiddlewares.length > 0) {
+                        routeConfig.middleware = folderMiddlewares;
+                    }
+                }
+                // Se tem middleware definido (mesmo que seja []), usa só esses (não adiciona os da pasta)
+                loaded.push(routeConfig);
+            }
+        }
+        catch (error) {
+            console_1.default.error(`Erro ao carregar a rota de API ${filePath}:`, error);
+        }
+    }
+    allBackendRoutes = loaded;
+}
+/**
+ * Encontra a rota de API correspondente para uma URL e método HTTP.
+ * @param pathname O caminho da URL (ex: "/api/users/123").
+ * @param method O método HTTP da requisição (GET, POST, etc.).
+ * @returns Um objeto com a rota e os parâmetros, ou null se não encontrar.
+ */
+function findMatchingBackendRoute(pathname, method) {
+    for (const route of allBackendRoutes) {
+        // Verifica se a rota tem um handler para o método HTTP atual
+        if (!route.pattern || !route[method.toUpperCase()])
+            continue;
+        const regexPattern = route.pattern.replace(/\[(\w+)\]/g, '(?<$1>[^/]+)');
+        const regex = new RegExp(`^${regexPattern}/?$`);
+        const match = pathname.match(regex);
+        if (match) {
+            return {
+                route,
+                params: match.groups || {}
+            };
+        }
+    }
+    return null;
+}
+/**
+ * Carrega o notFound.tsx se existir no diretório web
+ * @param webDir O diretório web onde procurar o notFound
+ * @returns O notFound carregado ou null se não existir
+ */
+function loadNotFound(webDir) {
+    const notFoundPath = path_1.default.join(webDir, 'notFound.tsx');
+    const notFoundPathJs = path_1.default.join(webDir, 'notFound.ts');
+    const notFoundFile = fs_1.default.existsSync(notFoundPath) ? notFoundPath :
+        fs_1.default.existsSync(notFoundPathJs) ? notFoundPathJs : null;
+    if (notFoundFile) {
+        const componentPath = path_1.default.relative(process.cwd(), notFoundFile).replace(/\\/g, '/');
+        const absolutePath = path_1.default.resolve(notFoundFile);
+        try {
+            // Limpa o cache antes de recarregar
+            clearRequireCache(absolutePath);
+            // Registra o arquivo como carregado
+            loadedNotFoundFiles.add(absolutePath);
+            notFoundComponent = { componentPath };
+            return notFoundComponent;
+        }
+        catch (error) {
+            console_1.default.error(`Erro ao carregar notFound ${notFoundFile}:`, error);
+            notFoundComponent = { componentPath };
+            return notFoundComponent;
+        }
+    }
+    notFoundComponent = null;
+    return null;
+}
+/**
+ * Retorna o componente 404 atual se carregado
+ */
+function getNotFound() {
+    return notFoundComponent;
+}

package/dist/types/framework.d.ts

@@ -0,0 +1,37 @@
+export interface GenericRequest {
+    method: string;
+    url: string;
+    headers: Record<string, string | string[]>;
+    body?: any;
+    query?: Record<string, any>;
+    params?: Record<string, string>;
+    cookies?: Record<string, string>;
+    raw?: any;
+}
+export interface GenericResponse {
+    status(code: number): GenericResponse;
+    header(name: string, value: string): GenericResponse;
+    cookie(name: string, value: string, options?: CookieOptions): GenericResponse;
+    clearCookie(name: string, options?: CookieOptions): GenericResponse;
+    json(data: any): void;
+    text(data: string): void;
+    send(data: any): void;
+    redirect(url: string): void;
+    raw?: any;
+}
+export interface CookieOptions {
+    domain?: string;
+    expires?: Date;
+    httpOnly?: boolean;
+    maxAge?: number;
+    path?: string;
+    secure?: boolean;
+    signed?: boolean;
+    sameSite?: boolean | 'lax' | 'strict' | 'none';
+}
+export type FrameworkType = 'express' | 'fastify' | 'native';
+export interface FrameworkAdapter {
+    type: FrameworkType;
+    parseRequest(req: any): GenericRequest;
+    createResponse(res: any): GenericResponse;
+}

package/dist/types/framework.js

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

package/dist/types.d.ts

@@ -0,0 +1,43 @@
+import type { ComponentType } from 'react';
+import type { GenericRequest } from './types/framework';
+import { HightJSRequest, HightJSResponse } from "./api/http";
+export interface HightJSOptions {
+    dev?: boolean;
+    hostname?: string;
+    port?: number;
+    dir?: string;
+    framework?: 'express' | 'fastify' | 'native';
+}
+export interface Metadata {
+    title?: string;
+    description?: string;
+    favicon?: string;
+}
+export interface RouteConfig {
+    pattern: string;
+    component: ComponentType<any>;
+    generateMetadata?: (params: any, req: GenericRequest) => Promise<Metadata> | Metadata;
+}
+export type RequestHandler = (req: any, res: any) => Promise<void>;
+/**
+ * Define o formato de uma função que manipula uma rota da API.
+ */
+export type BackendHandler = (request: HightJSRequest, // HWebRequest será importado onde necessário
+params: {
+    [key: string]: string;
+}) => Promise<HightJSResponse> | HightJSResponse;
+export type HightMiddleware = (request: HightJSRequest, // HWebRequest será importado onde necessário
+params: {
+    [key: string]: string;
+}, next: () => Promise<HightJSResponse>) => Promise<HightJSResponse> | HightJSResponse;
+/**
+ * Define a estrutura de cada rota da API, com suporte para métodos HTTP.
+ */
+export interface BackendRouteConfig {
+    pattern: string;
+    GET?: BackendHandler;
+    POST?: BackendHandler;
+    PUT?: BackendHandler;
+    DELETE?: BackendHandler;
+    middleware?: HightMiddleware[];
+}

package/dist/types.js

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

package/dist/typescript/use-client-plugin.d.ts

@@ -0,0 +1,5 @@
+/**
+ * TypeScript Plugin: require-use-client
+ * Integra a validação "use client" diretamente no TypeScript
+ */
+export default function createPlugin(info: any): any;

package/dist/typescript/use-client-plugin.js

@@ -0,0 +1,113 @@
+"use strict";
+/**
+ * TypeScript Plugin: require-use-client
+ * Integra a validação "use client" diretamente no TypeScript
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = createPlugin;
+const defaultConfig = {
+    enabled: true,
+    severity: 'error'
+};
+function isReactImport(node) {
+    if (!node.moduleSpecifier || node.moduleSpecifier.kind !== 10) { // StringLiteral = 10
+        return false;
+    }
+    const moduleName = node.moduleSpecifier.text;
+    return moduleName === 'react' || moduleName === 'react/jsx-runtime';
+}
+function hasReactHooks(node) {
+    if (!isReactImport(node) || !node.importClause) {
+        return false;
+    }
+    const reactHooks = [
+        'useState', 'useEffect', 'useContext', 'useReducer',
+        'useCallback', 'useMemo', 'useRef', 'useImperativeHandle',
+        'useLayoutEffect', 'useDebugValue', 'useDeferredValue',
+        'useTransition', 'useId', 'useSyncExternalStore',
+        'useInsertionEffect'
+    ];
+    if (node.importClause.namedBindings && node.importClause.namedBindings.kind === 271) { // NamedImports = 271
+        return node.importClause.namedBindings.elements.some((element) => reactHooks.includes(element.name.text));
+    }
+    return false;
+}
+function hasUseClientDirective(sourceFile) {
+    // Verifica se a primeira statement é uma expressão "use client"
+    if (sourceFile.statements.length === 0)
+        return false;
+    const firstStatement = sourceFile.statements[0];
+    if (firstStatement.kind === 233 && // ExpressionStatement = 233
+        firstStatement.expression.kind === 10) { // StringLiteral = 10
+        const value = firstStatement.expression.text;
+        return value === 'use client';
+    }
+    return false;
+}
+function isBackendFile(fileName) {
+    // Verifica se o arquivo está no diretório backend
+    return fileName.includes('/backend/') || fileName.includes('\\backend\\');
+}
+function isFrontendFile(fileName) {
+    // Verifica se é um arquivo frontend (não backend e dentro de src/web)
+    const isInWebDir = fileName.includes('/src/web/') || fileName.includes('\\src\\web\\');
+    const isNotBackend = !isBackendFile(fileName);
+    const isReactFile = fileName.endsWith('.tsx') || fileName.endsWith('.jsx');
+    return isInWebDir && isNotBackend && isReactFile;
+}
+function createDiagnostic(sourceFile, severity, start = 0, length = 1) {
+    const category = severity === 'error' ? 1 : 0; // Error = 1, Warning = 0
+    return {
+        file: sourceFile,
+        start,
+        length,
+        messageText: 'Arquivos que importam React ou hooks devem começar com "use client"',
+        category,
+        code: 9001, // Código customizado para o plugin HightJS
+        source: 'hightjs'
+    };
+}
+function createPlugin(info) {
+    const config = { ...defaultConfig, ...info.config };
+    if (!config.enabled) {
+        return info.languageService;
+    }
+    const proxy = Object.create(null);
+    // Proxy todas as funções do language service
+    for (let k of Object.keys(info.languageService)) {
+        const x = info.languageService[k];
+        proxy[k] = (...args) => x.apply(info.languageService, args);
+    }
+    // Sobrescreve getSemanticDiagnostics para adicionar nossa validação
+    proxy.getSemanticDiagnostics = (fileName) => {
+        const originalDiagnostics = info.languageService.getSemanticDiagnostics(fileName);
+        // Só valida arquivos frontend
+        if (!isFrontendFile(fileName)) {
+            return originalDiagnostics;
+        }
+        const sourceFile = info.languageService.getProgram()?.getSourceFile(fileName);
+        if (!sourceFile) {
+            return originalDiagnostics;
+        }
+        let hasReactImportOrHooks = false;
+        // Verifica se há imports do React ou hooks
+        function visitNode(node) {
+            if (node.kind === 270) { // ImportDeclaration = 270
+                if (isReactImport(node) || hasReactHooks(node)) {
+                    hasReactImportOrHooks = true;
+                }
+            }
+            node.forEachChild?.(visitNode);
+        }
+        visitNode(sourceFile);
+        // Se usa React mas não tem "use client", adiciona diagnóstico
+        if (hasReactImportOrHooks && !hasUseClientDirective(sourceFile)) {
+            const diagnostic = createDiagnostic(sourceFile, config.severity, 0, 1);
+            return [...originalDiagnostics, diagnostic];
+        }
+        return originalDiagnostics;
+    };
+    return proxy;
+}
+// Para compatibilidade com diferentes versões do TypeScript
+module.exports = createPlugin;

package/dist/validation.js

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