types-nora-api 0.0.146 → 0.0.148

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();
+}