types-nora-api 0.0.145 → 0.0.147

package/dist/classes.d.ts

@@ -734,18 +734,17 @@ type PaginaChave = keyof typeof PAGINAS;
 type PaginaObjeto = typeof PAGINAS[PaginaChave];
 type TelemetryConnectionInfo = {
     socketId: string;
-    userId?: number;
     username?: string;
     ip: string;
     userAgent?: string;
     connectedAt: number;
 };
-type TelemetryEventLog<T = any> = {
+type TelemetryEventLog<TPayload extends Record<string, unknown> = Record<string, unknown>> = {
     direction: 'in' | 'out';
     event: string;
     socketId: string;
-    userId?: number;
-    payload: T;
+    username?: string;
+    payload: TPayload;
     timestamp: number;
 };
 type TelemetrySnapshot = {

package/dist/scripts/extrairClasses.config.d.ts

@@ -0,0 +1,27 @@
+/**
+ * CONFIGURAÇÃO DE EXTRAÇÃO DE TIPOS
+ * Arquivo: extrairClasses.config.ts
+ */
+export declare const FilterType: {
+    readonly ALL: "ALL";
+    readonly MARKED: "MARKED";
+};
+export type FilterType = typeof FilterType[keyof typeof FilterType];
+export interface ExtractionSource {
+    source: string;
+    filter: FilterType;
+    description?: string;
+}
+export interface OutputConfig {
+    file: string;
+    header: string;
+}
+/**
+ * CONFIGURAÇÃO PRINCIPAL DE EXTRAÇÃO
+ */
+export declare const EXTRACTION_CONFIG: readonly ExtractionSource[];
+export declare const OUTPUT_CONFIG: OutputConfig;
+/**
+ * VALIDAÇÃO DA CONFIGURAÇÃO
+ */
+export declare function validateConfig(): boolean;

package/dist/scripts/extrairClasses.config.js

@@ -0,0 +1,66 @@
+/**
+ * CONFIGURAÇÃO DE EXTRAÇÃO DE TIPOS
+ * Arquivo: extrairClasses.config.ts
+ */
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+// Obter __dirname em ES Modules
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// CORREÇÃO: Estamos em src/@types/scripts/, precisamos subir 2 níveis para src/
+// e então acessar modules/ e shared/ que estão no MESMO nível de @types/
+const SRC_ROOT = path.resolve(__dirname, '../../');
+console.log('🔧 SRC_ROOT:', SRC_ROOT);
+// Tipos de filtro disponíveis
+export const FilterType = {
+    ALL: 'ALL',
+    MARKED: 'MARKED'
+};
+/**
+ * CONFIGURAÇÃO PRINCIPAL DE EXTRAÇÃO
+ */
+export const EXTRACTION_CONFIG = [
+    {
+        source: path.join(SRC_ROOT, 'modules/**/*.type.ts'),
+        filter: FilterType.ALL,
+        description: 'Todos os arquivos .type.ts dentro de src/modules'
+    },
+    {
+        source: path.join(SRC_ROOT, 'shared/types.ts'),
+        filter: FilterType.MARKED,
+        description: 'Arquivo src/shared/types.ts (apenas com @tipoCompartilhadoFront)'
+    },
+    {
+        source: path.join(SRC_ROOT, 'shared/ws.types.ts'),
+        filter: FilterType.ALL,
+        description: 'Arquivo src/shared/ws.types.ts (todas as definições exportadas)'
+    }
+];
+export const OUTPUT_CONFIG = {
+    file: path.resolve(__dirname, '../src/classes.ts'),
+    header: '// AUTO-GENERATED FILE - DO NOT EDIT\n// Gerado automaticamente por extrairClasses.ts\n\n'
+};
+/**
+ * VALIDAÇÃO DA CONFIGURAÇÃO
+ */
+export function validateConfig() {
+    const errors = [];
+    EXTRACTION_CONFIG.forEach((config, index) => {
+        if (!Object.values(FilterType).includes(config.filter)) {
+            errors.push(`Configuração [${index}]: Filtro '${config.filter}' não é válido`);
+        }
+        if (!config.source || typeof config.source !== 'string') {
+            errors.push(`Configuração [${index}]: Source deve ser uma string não vazia`);
+        }
+    });
+    if (!OUTPUT_CONFIG.file || typeof OUTPUT_CONFIG.file !== 'string') {
+        errors.push('OUTPUT_CONFIG.file deve ser uma string não vazia');
+    }
+    if (errors.length > 0) {
+        throw new Error(`Erro na configuração:\n${errors.join('\n')}`);
+    }
+    return true;
+}
+// Validação automática
+validateConfig();

package/dist/scripts/extrairClasses.d.ts

@@ -0,0 +1,9 @@
+/**
+ * SCRIPT PRINCIPAL DE EXTRAÇÃO DE TIPOS
+ * Arquivo: extrairClasses.ts
+ */
+/**
+ * Função principal do script
+ */
+declare function main(): Promise<void>;
+export default main;

package/dist/scripts/extrairClasses.js

@@ -0,0 +1,161 @@
+/**
+ * SCRIPT PRINCIPAL DE EXTRAÇÃO DE TIPOS
+ * Arquivo: extrairClasses.ts
+ */
+import { existsSync, writeFileSync } from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+// Configurações e utilitários
+import { EXTRACTION_CONFIG, OUTPUT_CONFIG, validateConfig } from './extrairClasses.config.js';
+import { findTypeFiles, ensureDirectoryExists, processFile, consolidateResults } from './extrairClasses.utils.js';
+// ==================================================
+// INICIALIZAÇÃO E CONFIGURAÇÃO
+// ==================================================
+// Obter __dirname em ES Modules
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// ==================================================
+// FUNÇÕES AUXILIARES
+// ==================================================
+/**
+ * Extrai mensagem de erro de forma segura
+ */
+function getErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+// ==================================================
+// FUNÇÕES DE PROCESSAMENTO
+// ==================================================
+/**
+ * Expande padrões glob para lista de arquivos concretos
+ */
+function expandSourcePattern(sourcePattern) {
+    // Se for um padrão glob (contém **)
+    if (sourcePattern.includes('**')) {
+        const baseDir = path.dirname(sourcePattern.replace(/\*\*/g, ''));
+        if (!existsSync(baseDir)) {
+            console.log(`   ❌ Diretório base não existe: ${baseDir}`);
+            return [];
+        }
+        return findTypeFiles(baseDir);
+    }
+    // Se for um arquivo específico
+    return [sourcePattern];
+}
+/**
+ * Processa uma configuração de extração individual
+ */
+function processExtractionConfig(config) {
+    console.log(`\n📁 ${config.description}`);
+    console.log(`   Source: ${config.source}`);
+    console.log(`   Filtro: ${config.filter}`);
+    try {
+        const filesToProcess = expandSourcePattern(config.source);
+        console.log(`   Arquivos encontrados: ${filesToProcess.length}`);
+        const results = [];
+        for (const filePath of filesToProcess) {
+            if (existsSync(filePath)) {
+                const result = processFile(filePath, config.filter);
+                results.push(result);
+                console.log(`   ✅ ${path.relative(process.cwd(), filePath)} → ${result.exportedNames.length} definições`);
+            }
+            else {
+                console.warn(`   ⚠️  Arquivo não encontrado: ${filePath}`);
+            }
+        }
+        return results;
+    }
+    catch (error) {
+        console.error(`   ❌ Erro:`, getErrorMessage(error));
+        return [];
+    }
+}
+/**
+ * Executa o pipeline completo de extração
+ */
+function executeExtractionPipeline() {
+    console.log('🚀 INICIANDO EXTRAÇÃO DE TIPOS');
+    console.log('='.repeat(60));
+    const allProcessingResults = [];
+    // Processa cada configuração na ordem definida
+    for (const config of EXTRACTION_CONFIG) {
+        const configResults = processExtractionConfig(config);
+        allProcessingResults.push(...configResults);
+    }
+    return {
+        processingResults: allProcessingResults,
+        totalFiles: allProcessingResults.length,
+        totalDefinitions: allProcessingResults.reduce((sum, result) => sum + result.exportedNames.length, 0)
+    };
+}
+/**
+ * Salva o conteúdo consolidado no arquivo de saída
+ */
+function saveConsolidatedFile(consolidatedContent) {
+    try {
+        ensureDirectoryExists(path.dirname(OUTPUT_CONFIG.file));
+        writeFileSync(OUTPUT_CONFIG.file, consolidatedContent, 'utf8');
+        console.log(`\n💾 ARQUIVO SALVO: ${OUTPUT_CONFIG.file}`);
+    }
+    catch (error) {
+        throw new Error(`Erro ao salvar arquivo: ${getErrorMessage(error)}`);
+    }
+}
+/**
+ * Exibe resumo da execução
+ */
+function displayExecutionSummary(extractionResult, outputPath) {
+    console.log('\n' + '='.repeat(60));
+    console.log('📊 RESUMO FINAL');
+    console.log('='.repeat(60));
+    console.log(`📁 Arquivos processados: ${extractionResult.totalFiles}`);
+    console.log(`📝 Definições extraídas: ${extractionResult.totalDefinitions}`);
+    console.log(`💾 Arquivo gerado: ${outputPath}`);
+    if (extractionResult.totalFiles === 0) {
+        console.log('❌ NENHUM ARQUIVO FOI PROCESSADO!');
+    }
+    else {
+        console.log('✅ EXTRAÇÃO CONCLUÍDA COM SUCESSO!');
+    }
+}
+// ==================================================
+// EXECUÇÃO PRINCIPAL
+// ==================================================
+/**
+ * Função principal do script
+ */
+async function main() {
+    try {
+        console.log('🔧 Iniciando validação da configuração...');
+        validateConfig();
+        console.log('🔧 Executando pipeline de extração...');
+        const extractionResult = executeExtractionPipeline();
+        if (extractionResult.totalFiles === 0) {
+            console.log('\n⚠️  ATENÇÃO: Nenhum arquivo foi processado!');
+            console.log('   Verifique:');
+            console.log('   1. Se os diretórios modules/ e shared/ existem');
+            console.log('   2. Se há arquivos .type.ts em modules/');
+            console.log('   3. Se shared/types.ts e shared/ws.types.ts existem');
+            return;
+        }
+        console.log('\n🔧 Consolidando resultados...');
+        const consolidatedContent = consolidateResults(extractionResult.processingResults, OUTPUT_CONFIG.header);
+        console.log('🔧 Salvando arquivo final...');
+        saveConsolidatedFile(consolidatedContent);
+        displayExecutionSummary(extractionResult, OUTPUT_CONFIG.file);
+    }
+    catch (error) {
+        console.error('\n❌ ERRO CRÍTICO:', getErrorMessage(error));
+        process.exit(1);
+    }
+}
+// EXECUTAR SEMPRE - SEM CONDIÇÃO
+main().catch(error => {
+    console.error('Erro não tratado:', getErrorMessage(error));
+    process.exit(1);
+});
+export default main;

package/dist/scripts/extrairClasses.utils.d.ts

@@ -0,0 +1,58 @@
+/**
+ * UTILITÁRIOS PARA EXTRAÇÃO DE TIPOS
+ * Arquivo: extrairClasses.utils.ts
+ */
+import * as ts from 'typescript';
+export interface FileProcessingResult {
+    content: string;
+    exportedNames: string[];
+    filePath: string;
+}
+/**
+ * Marcador para definições que devem ser compartilhadas com o frontend
+ */
+export declare const TIPO_COMPARTILHADO_FRONT_MARKER = "@tipoCompartilhadoFront";
+/**
+ * Verifica se um nó AST possui o marcador @tipoCompartilhadoFront
+ */
+export declare function hasTipoCompartilhadoFrontMarker(node: ts.Node, fileContent: string): boolean;
+/**
+ * Verifica se uma declaração de variável deve ser considerada para extração
+ */
+export declare function shouldExtractVariableStatement(node: ts.VariableStatement, snippet: string): boolean;
+/**
+ * Verifica se um nó deve ser extraído baseado no filtro
+ */
+export declare function shouldExtractNode(node: ts.Node, filterType: string, fileContent: string, snippet: string): boolean;
+/**
+ * Remove palavras-chave de export mantendo a declaração
+ */
+export declare function removeExportKeywords(content: string): string;
+/**
+ * Extrai nomes de identificadores de declarações de variável
+ */
+export declare function extractVariableNames(node: ts.VariableStatement): string[];
+/**
+ * Extrai o nome de um nó nomeado
+ */
+export declare function extractNodeName(node: ts.Node): string | null;
+/**
+ * Encontra recursivamente arquivos .type.ts em um diretório
+ */
+export declare function findTypeFiles(dir: string): string[];
+/**
+ * Garante que um diretório existe (cria se necessário)
+ */
+export declare function ensureDirectoryExists(dirPath: string): void;
+/**
+ * Cria um SourceFile TypeScript para análise AST
+ */
+export declare function createTypeScriptSourceFile(filePath: string, fileContent: string): ts.SourceFile;
+/**
+ * Processa um arquivo individual e extrai suas definições
+ */
+export declare function processFile(filePath: string, filterType: string): FileProcessingResult;
+/**
+ * Consolida resultados de múltiplos arquivos em conteúdo final
+ */
+export declare function consolidateResults(processingResults: FileProcessingResult[], header?: string): string;

package/dist/scripts/extrairClasses.utils.js

@@ -0,0 +1,255 @@
+/**
+ * UTILITÁRIOS PARA EXTRAÇÃO DE TIPOS
+ * Arquivo: extrairClasses.utils.ts
+ */
+import * as ts from 'typescript';
+import { readFileSync, existsSync, readdirSync, statSync, mkdirSync } from 'fs';
+import { join } from 'path';
+// ==================================================
+// CONSTANTES E CONFIGURAÇÕES COMPARTILHADAS
+// ==================================================
+/**
+ * Marcador para definições que devem ser compartilhadas com o frontend
+ */
+export const TIPO_COMPARTILHADO_FRONT_MARKER = '@tipoCompartilhadoFront';
+// ==================================================
+// TYPE GUARDS MELHORADOS
+// ==================================================
+function isNamedNode(node) {
+    return 'name' in node &&
+        node.name !== undefined &&
+        ts.isIdentifier(node.name);
+}
+function isVariableStatement(node) {
+    return ts.isVariableStatement(node);
+}
+function isClassDeclarationWithName(node) {
+    return ts.isClassDeclaration(node) && node.name !== undefined && ts.isIdentifier(node.name);
+}
+function isInterfaceDeclarationWithName(node) {
+    return ts.isInterfaceDeclaration(node) && node.name !== undefined && ts.isIdentifier(node.name);
+}
+function isTypeAliasDeclarationWithName(node) {
+    return ts.isTypeAliasDeclaration(node) && node.name !== undefined && ts.isIdentifier(node.name);
+}
+function isEnumDeclarationWithName(node) {
+    return ts.isEnumDeclaration(node) && node.name !== undefined && ts.isIdentifier(node.name);
+}
+function isModuleDeclarationWithName(node) {
+    return ts.isModuleDeclaration(node) && node.name !== undefined && ts.isIdentifier(node.name);
+}
+function isFunctionDeclarationWithName(node) {
+    return ts.isFunctionDeclaration(node) && node.name !== undefined && ts.isIdentifier(node.name);
+}
+// ==================================================
+// VALIDAÇÕES E VERIFICAÇÕES
+// ==================================================
+/**
+ * Verifica se um nó AST possui o marcador @tipoCompartilhadoFront
+ */
+export function hasTipoCompartilhadoFrontMarker(node, fileContent) {
+    const leadingComments = ts.getLeadingCommentRanges(fileContent, node.pos);
+    if (!leadingComments)
+        return false;
+    return leadingComments.some(comment => {
+        const commentText = fileContent.substring(comment.pos, comment.end);
+        return commentText.includes(TIPO_COMPARTILHADO_FRONT_MARKER);
+    });
+}
+/**
+ * Verifica se uma declaração de variável deve ser considerada para extração
+ */
+export function shouldExtractVariableStatement(node, snippet) {
+    const declarationList = node.declarationList;
+    const declarations = declarationList.declarations;
+    const hasAsConst = snippet.includes(' as const');
+    const hasTypeAnnotation = declarations.some(decl => decl.type);
+    const hasComplexInitializer = declarations.some(decl => {
+        if (!decl.initializer)
+            return false;
+        return (ts.isObjectLiteralExpression(decl.initializer) ||
+            ts.isArrayLiteralExpression(decl.initializer) ||
+            ts.isCallExpression(decl.initializer) ||
+            ts.isArrowFunction(decl.initializer) ||
+            ts.isFunctionExpression(decl.initializer));
+    });
+    return hasAsConst || hasTypeAnnotation || hasComplexInitializer;
+}
+// ==================================================
+// IDENTIFICAÇÃO DE TIPOS DE NÓ
+// ==================================================
+/**
+ * Verifica se um nó deve ser extraído baseado no filtro
+ */
+export function shouldExtractNode(node, filterType, fileContent, snippet) {
+    // Para filtro ALL, extrai tudo que é extraível
+    if (filterType === 'ALL') {
+        if (isVariableStatement(node)) {
+            return shouldExtractVariableStatement(node, snippet);
+        }
+        return (isClassDeclarationWithName(node) ||
+            isInterfaceDeclarationWithName(node) ||
+            isTypeAliasDeclarationWithName(node) ||
+            isEnumDeclarationWithName(node) ||
+            isModuleDeclarationWithName(node) ||
+            isFunctionDeclarationWithName(node));
+    }
+    // Para filtro MARKED, só extrai se tiver o marcador
+    if (filterType === 'MARKED') {
+        const hasMarker = hasTipoCompartilhadoFrontMarker(node, fileContent);
+        if (isVariableStatement(node)) {
+            return hasMarker || shouldExtractVariableStatement(node, snippet);
+        }
+        return hasMarker && (isClassDeclarationWithName(node) ||
+            isInterfaceDeclarationWithName(node) ||
+            isTypeAliasDeclarationWithName(node) ||
+            isEnumDeclarationWithName(node) ||
+            isModuleDeclarationWithName(node) ||
+            isFunctionDeclarationWithName(node));
+    }
+    return false;
+}
+// ==================================================
+// MANIPULAÇÃO DE CONTEÚDO
+// ==================================================
+/**
+ * Remove palavras-chave de export mantendo a declaração
+ */
+export function removeExportKeywords(content) {
+    return content
+        .replace(/^export\s+(default\s+)?/gm, '')
+        .replace(/export\s+(default\s+)?\{[^}]+\};?\n?/g, '')
+        .trim();
+}
+/**
+ * Extrai nomes de identificadores de declarações de variável
+ */
+export function extractVariableNames(node) {
+    const names = [];
+    const declarationList = node.declarationList;
+    declarationList.declarations.forEach(declaration => {
+        if (ts.isIdentifier(declaration.name)) {
+            names.push(declaration.name.text);
+        }
+    });
+    return names;
+}
+/**
+ * Extrai o nome de um nó nomeado
+ */
+export function extractNodeName(node) {
+    if (isClassDeclarationWithName(node))
+        return node.name.text;
+    if (isInterfaceDeclarationWithName(node))
+        return node.name.text;
+    if (isTypeAliasDeclarationWithName(node))
+        return node.name.text;
+    if (isEnumDeclarationWithName(node))
+        return node.name.text;
+    if (isModuleDeclarationWithName(node))
+        return node.name.text;
+    if (isFunctionDeclarationWithName(node))
+        return node.name.text;
+    return null;
+}
+// ==================================================
+// PROCESSAMENTO DE ARQUIVOS
+// ==================================================
+/**
+ * Encontra recursivamente arquivos .type.ts em um diretório
+ */
+export function findTypeFiles(dir) {
+    if (!existsSync(dir)) {
+        throw new Error(`Diretório não encontrado: ${dir}`);
+    }
+    let results = [];
+    const items = readdirSync(dir);
+    for (const item of items) {
+        const itemPath = join(dir, item);
+        const stat = statSync(itemPath);
+        if (stat.isDirectory()) {
+            results = results.concat(findTypeFiles(itemPath));
+        }
+        else if (item.endsWith('.type.ts')) {
+            results.push(itemPath);
+        }
+    }
+    return results;
+}
+/**
+ * Garante que um diretório existe (cria se necessário)
+ */
+export function ensureDirectoryExists(dirPath) {
+    if (!existsSync(dirPath)) {
+        mkdirSync(dirPath, { recursive: true });
+    }
+}
+/**
+ * Cria um SourceFile TypeScript para análise AST
+ */
+export function createTypeScriptSourceFile(filePath, fileContent) {
+    return ts.createSourceFile(filePath, fileContent, ts.ScriptTarget.Latest, true);
+}
+// ==================================================
+// PROCESSAMENTO MODULAR DO OUTPUT
+// ==================================================
+/**
+ * Processa um arquivo individual e extrai suas definições
+ */
+export function processFile(filePath, filterType) {
+    if (!existsSync(filePath)) {
+        console.warn(`Arquivo não encontrado: ${filePath}`);
+        return { content: '', exportedNames: [], filePath };
+    }
+    const fileContent = readFileSync(filePath, 'utf8');
+    const sourceFile = createTypeScriptSourceFile(filePath, fileContent);
+    let extractedContent = '';
+    const exportedNames = [];
+    ts.forEachChild(sourceFile, (node) => {
+        const snippet = fileContent.substring(node.pos, node.end);
+        if (shouldExtractNode(node, filterType, fileContent, snippet)) {
+            const cleanedContent = removeExportKeywords(snippet);
+            extractedContent += `${cleanedContent}\n`;
+            // Coleta nomes baseado no tipo de nó
+            if (isVariableStatement(node)) {
+                const names = extractVariableNames(node);
+                exportedNames.push(...names);
+            }
+            else {
+                const name = extractNodeName(node);
+                if (name) {
+                    exportedNames.push(name);
+                }
+            }
+        }
+    });
+    console.log(`Processado: ${filePath} (${exportedNames.length} definições)`);
+    return {
+        content: extractedContent,
+        exportedNames,
+        filePath
+    };
+}
+/**
+ * Consolida resultados de múltiplos arquivos em conteúdo final
+ */
+export function consolidateResults(processingResults, header = '') {
+    let consolidatedContent = header;
+    const allExportedNames = new Set();
+    // Adiciona conteúdo de cada arquivo
+    for (const result of processingResults) {
+        if (result.content) {
+            consolidatedContent += result.content + '\n';
+            result.exportedNames.forEach(name => allExportedNames.add(name));
+        }
+    }
+    // Adiciona export final se houver nomes
+    if (allExportedNames.size > 0) {
+        consolidatedContent += `\nexport {\n  ${Array.from(allExportedNames).join(',\n  ')}\n};\n`;
+    }
+    // Limpeza final
+    return consolidatedContent
+        .replace(/\n{3,}/g, '\n\n')
+        .replace(/^\s+$/gm, '')
+        .trim();
+}