@silasfmartins/testhub 1.0.0

package/dist/src/config/jest-safe-setup.js

@@ -0,0 +1,369 @@
+/**
+ * 🔧 AutoCore Jest-Safe Setup - Configuração Avançada Jest/Vitest
+ * @silasfmartins/testhub v1.1.48
+ *
+ * Sistema automático de resolução de conflitos Jest/Vitest para projetos
+ * que utilizam ambos os padrões .test.ts e .spec.ts
+ *
+ * OPÇÃO B COMPLETA: 8 Métodos Avançados de Resolução
+ */
+// 🚨 CRÍTICO: Interceptar Object.defineProperty IMEDIATAMENTE
+// Isso DEVE acontecer antes de qualquer outro código para evitar o erro:
+// "TypeError: Cannot redefine property: Symbol($$jest-matchers-object)"
+const _originalDefineProperty = Object.defineProperty;
+const _interceptedSymbols = new Set();
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+Object.defineProperty = function (obj, prop, descriptor) {
+    // Detectar se é um símbolo Jest/Vitest/matchers
+    const isMatcherSymbol = typeof prop === 'symbol' &&
+        (prop.toString().includes('jest') ||
+            prop.toString().includes('vitest') ||
+            prop.toString().includes('matchers'));
+    if (isMatcherSymbol) {
+        // Verificar se já existe no objeto
+        const existingDescriptor = Object.getOwnPropertyDescriptor(obj, prop);
+        if (existingDescriptor) {
+            // Se já existe e não é configurável, pular silenciosamente
+            if (!existingDescriptor.configurable) {
+                // Já foi definido por outro framework, ignorar tentativa de redefinição
+                _interceptedSymbols.add(prop);
+                return obj;
+            }
+        }
+        // Forçar a propriedade a ser configurável para permitir futuras redefinições
+        const safeDescriptor = {
+            ...descriptor,
+            configurable: true,
+        };
+        try {
+            return _originalDefineProperty.call(Object, obj, prop, safeDescriptor);
+        }
+        catch {
+            // Se ainda falhar, simplesmente ignorar
+            _interceptedSymbols.add(prop);
+            return obj;
+        }
+    }
+    // Para outras propriedades, usar comportamento padrão
+    return _originalDefineProperty.call(Object, obj, prop, descriptor);
+};
+const SUBSTRING_START = 2;
+const RANDOM_LENGTH = 9;
+const RADIX_BASE_36 = 36;
+/**
+ * 🛡️ CRÍTICO: Pré-limpeza imediata de símbolos Jest
+ * Executado ANTES de qualquer import do Vitest para evitar conflitos
+ */
+function preCleanJestSymbols() {
+    try {
+        // Limpar propriedades Jest no globalThis antes que o Vitest as defina
+        const jestSymbolPatterns = ['jest', 'matchers', 'asymmetric'];
+        const globalObj = globalThis;
+        // Obter todos os símbolos do globalThis
+        const symbols = Object.getOwnPropertySymbols(globalThis);
+        for (const sym of symbols) {
+            const symStr = sym.toString().toLowerCase();
+            const isJestRelated = jestSymbolPatterns.some((pattern) => symStr.includes(pattern));
+            if (isJestRelated) {
+                try {
+                    // Tentar deletar diretamente
+                    delete globalObj[sym];
+                }
+                catch {
+                    // Se não conseguir deletar, tentar tornar configurável
+                    try {
+                        _originalDefineProperty.call(Object, globalThis, sym, {
+                            configurable: true,
+                            writable: true,
+                            value: globalObj[sym],
+                        });
+                        delete globalObj[sym];
+                    }
+                    catch {
+                        // Ignorar - não conseguimos limpar este símbolo
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        // Ignorar erros de pré-limpeza
+    }
+}
+// 🚨 Executar pré-limpeza IMEDIATAMENTE ao carregar o módulo
+preCleanJestSymbols();
+/**
+ * 🛡️ Função Principal: Resolver Conflitos Jest/Vitest
+ *
+ * Implementa 8 métodos de proteção para evitar:
+ * - TypeError: Cannot redefine property: Symbol($$jest-matchers-object)
+ * - Conflitos entre expect() do Jest vs Vitest
+ * - Problemas de Symbol registry
+ * - Redefinição de propriedades globais
+ */
+export function resolveJestVitestConflict() {
+    // Log silencioso apenas em desenvolvimento
+    const isDevMode = process.env.NODE_ENV !== 'production';
+    if (isDevMode) {
+        // eslint-disable-next-line no-console
+    }
+    try {
+        // 🔧 MÉTODO 0: Pré-limpeza (já executada, mas garantir)
+        preCleanJestSymbols();
+        // 🔧 MÉTODO 1: Limpar Symbol registry global
+        clearSymbolRegistry(isDevMode);
+        // 🔧 MÉTODO 2: Interceptar Object.defineProperty para evitar redefinições
+        interceptDefineProperty(isDevMode);
+        // 🔧 MÉTODO 3: Configurar isolamento de worker process
+        configureWorkerIsolation(isDevMode);
+        // 🔧 MÉTODO 4: Limpar module cache para símbolos Jest
+        clearModuleCache(isDevMode);
+        // 🔧 MÉTODO 5: Configurar globalThis de forma segura
+        configureGlobalThis(isDevMode);
+        // 🔧 MÉTODO 6: Configurar variáveis de ambiente específicas
+        configureEnvironmentVariables(isDevMode);
+        // 🔧 MÉTODO 7: Interceptar require para Jest packages
+        interceptRequire(isDevMode);
+        // 🔧 MÉTODO 8: Cleanup de timers e recursos
+        cleanupResources(isDevMode);
+        // 🔧 Auto-detecção de ambiente
+        autoConfigureEnvironment(isDevMode);
+        if (isDevMode) {
+            // eslint-disable-next-line no-console
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (isDevMode) {
+            // eslint-disable-next-line no-console
+            console.warn(`⚠️ [AutoCore] Warning during Jest/Vitest setup: ${errorMessage}`);
+        }
+        // Não fazer throw para não quebrar a inicialização
+    }
+}
+/**
+ * 🔧 MÉTODO 1: Limpar Symbol registry global
+ */
+function clearSymbolRegistry(isDevMode) {
+    if (typeof globalThis !== 'undefined' && globalThis.Symbol) {
+        const symbolRegistry = globalThis.Symbol
+            ._registry || new Map();
+        // Limpar símbolos Jest específicos
+        const jestSymbols = [
+            '$$jest-matchers-object',
+            '$$jest-asymmetric-matchers-object',
+        ];
+        for (const jestSymbol of jestSymbols) {
+            for (const [key] of symbolRegistry) {
+                if (key?.includes?.('jest')) {
+                    symbolRegistry.delete(key);
+                }
+            }
+        }
+        if (isDevMode) {
+            // eslint-disable-next-line no-console
+        }
+    }
+}
+/**
+ * 🔧 MÉTODO 2: Interceptar Object.defineProperty para evitar redefinições
+ * NOTA: A interceptação principal já acontece no topo do arquivo.
+ * Este método apenas marca como interceptado para evitar duplicação.
+ */
+function interceptDefineProperty(_isDevMode) {
+    // A interceptação já foi feita no topo do arquivo
+    // Apenas marcar como interceptado
+    const globalObj = globalThis;
+    globalObj.__AUTOCORE_DEFINE_PROPERTY_INTERCEPTED__ = true;
+}
+/**
+ * 🔧 MÉTODO 3: Configurar isolamento de worker process
+ */
+function configureWorkerIsolation(isDevMode) {
+    if (typeof process !== 'undefined') {
+        const PROCESS_ID = `autocore-${Date.now()}-${Math.random().toString(RADIX_BASE_36).substr(SUBSTRING_START, RANDOM_LENGTH)}`;
+        process.env.AUTOCORE_PROCESS_ID = PROCESS_ID;
+        process.env.VITEST_WORKER_ID = PROCESS_ID;
+        process.env.NODE_ENV = process.env.NODE_ENV || 'test';
+        // Configurações específicas para evitar conflitos
+        process.env.FORCE_COLOR = '0'; // Evitar conflitos de output
+        process.env.CI = process.env.CI || 'false';
+        process.env.VITEST_POOL_ID = '1'; // Pool único
+        if (isDevMode) {
+            // eslint-disable-next-line no-console
+        }
+    }
+}
+/**
+ * 🔧 MÉTODO 4: Limpar module cache para símbolos Jest
+ */
+function clearModuleCache(isDevMode) {
+    if (typeof require !== 'undefined' && require.cache) {
+        const cacheKeys = Object.keys(require.cache);
+        for (const key of cacheKeys) {
+            if (key.includes('jest') ||
+                key.includes('@jest') ||
+                key.includes('expect')) {
+                try {
+                    delete require.cache[key];
+                }
+                catch {
+                    // Ignorar erros de limpeza de cache
+                }
+            }
+        }
+        if (isDevMode) {
+            // eslint-disable-next-line no-console
+        }
+    }
+}
+/**
+ * 🔧 MÉTODO 5: Configurar globalThis de forma segura
+ */
+function configureGlobalThis(isDevMode) {
+    if (typeof globalThis !== 'undefined') {
+        // Marcar como ambiente AutoCore
+        const globalObj = globalThis;
+        globalObj.__AUTOCORE_INITIALIZED__ = true;
+        globalObj.__AUTOCORE_PROCESS_ID__ = process.env.AUTOCORE_PROCESS_ID;
+        // Evitar conflitos de expect se já existe
+        if (!globalObj.expect) {
+            // Só definir expect se não existir
+            try {
+                const { expect } = require('vitest');
+                globalObj.expect = expect;
+            }
+            catch {
+                // Se vitest não disponível, continuar sem expect global
+            }
+        }
+        if (isDevMode) {
+            // eslint-disable-next-line no-console
+        }
+    }
+}
+/**
+ * 🔧 MÉTODO 6: Configurar variáveis de ambiente específicas
+ */
+function configureEnvironmentVariables(isDevMode) {
+    if (typeof process !== 'undefined') {
+        // Variáveis para controle de execução
+        process.env.AUTOCORE_JEST_SAFE = 'true';
+        process.env.VITEST_GLOBALS = 'false'; // CRÍTICO: evitar globals
+        process.env.VITEST_ISOLATE = 'true';
+        process.env.VITEST_SINGLE_FORK = 'true';
+        // Configurações de memory management
+        const nodeOptions = [
+            process.env.NODE_OPTIONS,
+            '--max-old-space-size=4096',
+            '--no-deprecation',
+            '--no-warnings',
+            '--unhandled-rejections=warn',
+        ].filter(Boolean);
+        process.env.NODE_OPTIONS = nodeOptions.join(' ');
+        if (isDevMode) {
+            // eslint-disable-next-line no-console
+        }
+    }
+}
+/**
+ * 🔧 MÉTODO 7: Interceptar require para Jest packages
+ */
+function interceptRequire(isDevMode) {
+    if (typeof require !== 'undefined') {
+        const Module = require('node:module');
+        const originalRequire = Module.prototype.require;
+        Module.prototype.require = function (id, ...args) {
+            // Se está tentando carregar Jest em ambiente Vitest, bloquear
+            if (process.env.VITEST && (id.includes('@jest/') || id === 'jest')) {
+                if (isDevMode) {
+                    // eslint-disable-next-line no-console
+                    console.warn(`[AutoCore] Bloqueando carregamento de ${id} em ambiente Vitest`);
+                }
+                return {}; // Retornar objeto vazio
+            }
+            return originalRequire.apply(this, [id, ...args]);
+        };
+        if (isDevMode) {
+            // eslint-disable-next-line no-console
+        }
+    }
+}
+/**
+ * 🔧 MÉTODO 8: Cleanup de timers e recursos
+ */
+function cleanupResources(isDevMode) {
+    try {
+        // Limpar timers que podem causar conflitos
+        if (typeof global !== 'undefined') {
+            const timerNames = ['setTimeout', 'setInterval', 'setImmediate'];
+            for (const timerName of timerNames) {
+                const globalObj = global;
+                const originalTimer = globalObj[timerName];
+                if (originalTimer && typeof originalTimer.unref === 'function') {
+                    globalObj[timerName] = function (...args) {
+                        const timer = originalTimer.apply(this, args);
+                        if (timer && typeof timer.unref === 'function') {
+                            timer.unref(); // Permitir que processo termine sem aguardar timer
+                        }
+                        return timer;
+                    };
+                }
+            }
+        }
+    }
+    catch {
+        // Ignorar erros de cleanup
+    }
+    if (isDevMode) {
+        // eslint-disable-next-line no-console
+    }
+}
+/**
+ * 🔧 Auto-detecção de ambiente e configuração automática
+ */
+function autoConfigureEnvironment(isDevMode) {
+    try {
+        // Detectar se estamos em ambiente Vitest
+        const isVitest = process.env.VITEST ||
+            process.argv.some((arg) => arg.includes('vitest')) ||
+            typeof globalThis.__vitest_worker__ !==
+                'undefined';
+        // Detectar se Jest está presente
+        const hasJest = typeof globalThis.jest !== 'undefined' ||
+            Boolean(process.env.JEST_WORKER_ID) ||
+            (typeof require !== 'undefined' &&
+                (() => {
+                    try {
+                        require('@jest/globals');
+                        return true;
+                    }
+                    catch {
+                        return false;
+                    }
+                })());
+        if (isDevMode && process.env.AUTOCORE_DEBUG_LOGS) {
+            // eslint-disable-next-line no-console
+            console.log(`🔧 [AutoCore] Environment Detection: Vitest=${isVitest}, Jest=${hasJest}`);
+        }
+        if (isVitest) {
+            process.env.AUTOCORE_RUNTIME = 'vitest';
+            process.env.VITEST_GLOBALS = 'false'; // CRÍTICO
+        }
+        else if (hasJest) {
+            process.env.AUTOCORE_RUNTIME = 'jest';
+        }
+        else {
+            process.env.AUTOCORE_RUNTIME = 'unknown';
+        }
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (isDevMode && process.env.AUTOCORE_DEBUG_LOGS) {
+            // eslint-disable-next-line no-console
+            console.warn(`⚠️ [AutoCore] Environment detection error: ${errorMessage}`);
+        }
+    }
+}
+// 🚀 Auto-inicialização
+resolveJestVitestConflict();

package/dist/src/config/timeouts.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Configuração centralizada de timeouts do framework.
+ *
+ * Em vez de espalhar valores mágicos pelo código, todos os timeouts
+ * ficam definidos aqui. Os valores podem ser sobrescritos via variáveis
+ * de ambiente.
+ *
+ * @module config/timeouts
+ */
+export declare const TIMEOUTS: {
+    /** Delay mínimo para estabilizar efeitos visuais (50ms) */
+    readonly SHORT: number;
+    /** Delay médio para transições DOM (150ms) */
+    readonly MEDIUM: number;
+    /** Delay longo para operações de rede/renderização (1000ms) */
+    readonly LONG: number;
+    /** Delay para verificação de estabilidade DOM (300ms) */
+    readonly DOM_STABILITY: number;
+    /** Timeout para waitForElement padrão (30s) */
+    readonly ELEMENT_WAIT: number;
+    /** Timeout para navegação de página (60s) */
+    readonly NAVIGATION: number;
+    /** Timeout para chamadas de API (30s) */
+    readonly API_REQUEST: number;
+    /** Cooldown entre refresh DOM (200ms) */
+    readonly DOM_REFRESH_COOLDOWN: number;
+    /** TTL do cache de seletores (500ms) */
+    readonly SELECTOR_CACHE_TTL: number;
+    /** Intervalo do interceptor setTimeout (100ms) */
+    readonly INTERCEPTOR_INIT_DELAY: number;
+};
+export type TimeoutKey = keyof typeof TIMEOUTS;

package/dist/src/config/timeouts.js

@@ -0,0 +1,38 @@
+/**
+ * Configuração centralizada de timeouts do framework.
+ *
+ * Em vez de espalhar valores mágicos pelo código, todos os timeouts
+ * ficam definidos aqui. Os valores podem ser sobrescritos via variáveis
+ * de ambiente.
+ *
+ * @module config/timeouts
+ */
+function envNumber(key, fallback) {
+    const v = process.env[key];
+    if (v === undefined || v === '')
+        return fallback;
+    const n = Number(v);
+    return Number.isFinite(n) ? n : fallback;
+}
+export const TIMEOUTS = {
+    /** Delay mínimo para estabilizar efeitos visuais (50ms) */
+    SHORT: envNumber('AUTOCORE_TIMEOUT_SHORT', 50),
+    /** Delay médio para transições DOM (150ms) */
+    MEDIUM: envNumber('AUTOCORE_TIMEOUT_MEDIUM', 150),
+    /** Delay longo para operações de rede/renderização (1000ms) */
+    LONG: envNumber('AUTOCORE_TIMEOUT_LONG', 1000),
+    /** Delay para verificação de estabilidade DOM (300ms) */
+    DOM_STABILITY: envNumber('AUTOCORE_TIMEOUT_DOM_STABILITY', 300),
+    /** Timeout para waitForElement padrão (30s) */
+    ELEMENT_WAIT: envNumber('AUTOCORE_TIMEOUT_ELEMENT_WAIT', 30_000),
+    /** Timeout para navegação de página (60s) */
+    NAVIGATION: envNumber('AUTOCORE_TIMEOUT_NAVIGATION', 60_000),
+    /** Timeout para chamadas de API (30s) */
+    API_REQUEST: envNumber('AUTOCORE_TIMEOUT_API_REQUEST', 30_000),
+    /** Cooldown entre refresh DOM (200ms) */
+    DOM_REFRESH_COOLDOWN: envNumber('AUTOCORE_DOM_REFRESH_COOLDOWN_MS', 200),
+    /** TTL do cache de seletores (500ms) */
+    SELECTOR_CACHE_TTL: envNumber('AUTOCORE_SELECTOR_CACHE_TTL_MS', 500),
+    /** Intervalo do interceptor setTimeout (100ms) */
+    INTERCEPTOR_INIT_DELAY: envNumber('AUTOCORE_INTERCEPTOR_INIT_DELAY', 100),
+};

package/dist/src/desktop/DesktopActions.d.ts

@@ -0,0 +1,46 @@
+export declare class DesktopActions {
+    private static ensureDriver;
+    private static executarComLog;
+    private static runSikuliIfNeeded;
+    static click(element: any, description?: string, getSnapshot?: boolean): Promise<{
+        stdout: string;
+        stderr: string;
+    } | undefined>;
+    static doubleClick(element: any, description?: string, getSnapshot?: boolean): Promise<{
+        stdout: string;
+        stderr: string;
+    } | undefined>;
+    static setText(element: any, text: string, description?: string, getSnapshot?: boolean): Promise<{
+        stdout: string;
+        stderr: string;
+    } | undefined>;
+    static selectInTableActiveRow(element: any, rowActivate: number, description?: string, getSnapshot?: boolean): Promise<void>;
+    static clickOptionInTable(element: any, item: string, description?: string, getSnapshot?: boolean): Promise<void>;
+    static clickOptionInTableRowAndHeader(element: any, row: number, header: string, description?: string, getSnapshot?: boolean): Promise<void>;
+    static doubleClickOptionInTable(element: any, item: string, description?: string, getSnapshot?: boolean): Promise<void>;
+    static selectRowInTable(element: any, row: number, description?: string, getSnapshot?: boolean): Promise<void>;
+    static selectRowOptionInTable(element: any, itens: string[], description?: string, getSnapshot?: boolean): Promise<void>;
+    static selectInTreeView(element: any, pathStr: string, description?: string, getSnapshot?: boolean): Promise<void>;
+    static selectInTabControl(element: any, item: string, description?: string, getSnapshot?: boolean): Promise<void>;
+    static setValueTable(element: any, value: string, row: number, column: string, description?: string, getSnapshot?: boolean): Promise<void>;
+    static setStateCheckBox(element: any, checked: boolean, description?: string, getSnapshot?: boolean): Promise<void>;
+    static implicitWait(element: any, timeOrDesc?: number | string, descriptionOrGet?: string | boolean, getSnapshot?: boolean): Promise<void>;
+    static selectInList(element: any, text: string, description?: string, getSnapshot?: boolean): Promise<void>;
+    static validateObject(element: any, arg1?: any, arg2?: any, arg3?: any): Promise<boolean>;
+    static setTextTable(element: any, row: number, columnHeader: string, value: string, description?: string, getSnapshot?: boolean): Promise<void>;
+    static getText(element: any, description?: string, getSnapshot?: boolean): Promise<string>;
+    static getTextEditor(element: any, description?: string, getSnapshot?: boolean): Promise<string>;
+    static getAttachedText(element: any, description?: string, getSnapshot?: boolean): Promise<string>;
+    static getLabel(element: any, description?: string, getSnapshot?: boolean): Promise<string>;
+    static selectOptionMenu(element: any, description?: string, getSnapshot?: boolean): Promise<{
+        stdout: string;
+        stderr: string;
+    } | undefined>;
+    static selectOptionSubMenu(element: any, path: string, description?: string, getSnapshot?: boolean): Promise<void>;
+    static closeWindow(element: any, description?: string): Promise<void>;
+    static maximizeWindow(description?: string, getSnapshot?: boolean): Promise<void>;
+    static pressKey(key: number, description?: string): Promise<void>;
+    static releaseKey(key: number, description?: string): Promise<void>;
+    static waitForElementJavaToDisappear(object: any, time?: number): Promise<boolean>;
+}
+export default DesktopActions;