@designliquido/delegua-interface-grafica 0.0.0

package/fontes/infraestruturas/electron/infraestrutura-electron.ts

@@ -0,0 +1,284 @@
+import { InfraestruturaGraficaInterface } from '../../interfaces/infraestrutura-grafica-interface';
+import { ComponenteInterfaceGraficaInterface } from '../../interfaces/componente-interface-grafica-interface';
+
+/**
+ * Mapeamento de nomes de eventos Delégua para eventos DOM correspondentes.
+ */
+const MAPA_EVENTOS: Record<string, string> = {
+    clique: 'click',
+    alterado: 'input',
+    tecla: 'keydown',
+    foco: 'focus',
+    desfoco: 'blur',
+};
+
+/**
+ * Infraestrutura de interface gráfica para o ambiente Electron.
+ * Cria elementos DOM no `document.body` da janela do Electron.
+ *
+ * O programa Delégua enxerga cada componente como um identificador opaco
+ * (`ComponenteInterfaceGraficaInterface`). Internamente, este infraestrutura mantém um mapa entre esses
+ * identificadores e os `HTMLElement`s correspondentes.
+ *
+ * Cada instância de `InfraestruturaElectron` gerencia uma janela independente:
+ * um `div` flutuante criado sobre o conteúdo existente da página.
+ */
+export class InfraestruturaElectron implements InfraestruturaGraficaInterface {
+    private readonly elementosPorId: Map<string, HTMLElement> = new Map();
+    private contadorIds = 0;
+    private sobreposicao: HTMLElement | null = null;
+    private resolverLaco: (() => void) | null = null;
+
+    // -------------------------------------------------------------------------
+    // Helpers internos
+    // -------------------------------------------------------------------------
+
+    private proximoId(): string {
+        return `delegua-gui-${++this.contadorIds}`;
+    }
+
+    private registrar(elemento: HTMLElement): ComponenteInterfaceGraficaInterface {
+        const idComponente = this.proximoId();
+        this.elementosPorId.set(idComponente, elemento);
+        return { idComponente };
+    }
+
+    private obterElemento(componente: ComponenteInterfaceGraficaInterface): HTMLElement {
+        const elemento = this.elementosPorId.get(componente.idComponente);
+        if (!elemento) {
+            throw new Error(
+                `Componente '${componente.idComponente}' não encontrado. ` +
+                `Verifique se ele foi criado pela mesma instância de InfraestruturaElectron.`
+            );
+        }
+        return elemento;
+    }
+
+    // -------------------------------------------------------------------------
+    // Criação de componentes
+    // -------------------------------------------------------------------------
+
+    criarJanela(largura: number, altura: number, titulo: string): ComponenteInterfaceGraficaInterface {
+        this.sobreposicao = document.createElement('div');
+        Object.assign(this.sobreposicao.style, {
+            position: 'fixed',
+            top: '0',
+            left: '0',
+            width: '100%',
+            height: '100%',
+            background: 'rgba(0, 0, 0, 0.4)',
+            display: 'flex',
+            alignItems: 'center',
+            justifyContent: 'center',
+            zIndex: '9999',
+            fontFamily: 'system-ui, -apple-system, sans-serif',
+        });
+
+        const moldura = document.createElement('div');
+        Object.assign(moldura.style, {
+            background: '#f0f0f0',
+            border: '1px solid #aaa',
+            borderRadius: '5px',
+            width: `${largura}px`,
+            height: `${altura}px`,
+            display: 'flex',
+            flexDirection: 'column',
+            boxShadow: '0 6px 24px rgba(0, 0, 0, 0.4)',
+            overflow: 'hidden',
+        });
+
+        // Barra de título
+        const barraTitulo = document.createElement('div');
+        Object.assign(barraTitulo.style, {
+            background: '#3c3c3c',
+            color: 'white',
+            padding: '6px 10px',
+            fontSize: '13px',
+            display: 'flex',
+            alignItems: 'center',
+            justifyContent: 'space-between',
+            userSelect: 'none',
+            flexShrink: '0',
+        });
+
+        const textoTitulo = document.createElement('span');
+        textoTitulo.textContent = titulo;
+
+        const botaoFechar = document.createElement('button');
+        botaoFechar.textContent = '×';
+        Object.assign(botaoFechar.style, {
+            background: 'none',
+            border: 'none',
+            color: 'white',
+            fontSize: '20px',
+            lineHeight: '1',
+            cursor: 'pointer',
+            padding: '0 2px',
+        });
+        botaoFechar.addEventListener('click', () => this.encerrar());
+
+        barraTitulo.appendChild(textoTitulo);
+        barraTitulo.appendChild(botaoFechar);
+
+        // Área de conteúdo — é aqui que os filhos da janela são inseridos
+        const areaConteudo = document.createElement('div');
+        Object.assign(areaConteudo.style, {
+            flex: '1',
+            overflow: 'auto',
+            padding: '10px',
+            display: 'flex',
+            flexDirection: 'column',
+            gap: '8px',
+            boxSizing: 'border-box',
+        });
+
+        moldura.appendChild(barraTitulo);
+        moldura.appendChild(areaConteudo);
+        this.sobreposicao.appendChild(moldura);
+        document.body.appendChild(this.sobreposicao);
+
+        // O idComponente da janela aponta para areaConteudo,
+        // onde os filhos serão inseridos diretamente.
+        return this.registrar(areaConteudo);
+    }
+
+    criarBotao(pai: ComponenteInterfaceGraficaInterface, rotulo: string): ComponenteInterfaceGraficaInterface {
+        const elementoPai = this.obterElemento(pai);
+        const botao = document.createElement('button');
+        botao.textContent = rotulo;
+        Object.assign(botao.style, {
+            padding: '6px 16px',
+            fontSize: '13px',
+            cursor: 'pointer',
+            border: '1px solid #999',
+            borderRadius: '3px',
+            background: '#e8e8e8',
+            alignSelf: 'flex-start',
+        });
+        elementoPai.appendChild(botao);
+        return this.registrar(botao);
+    }
+
+    criarRotulo(pai: ComponenteInterfaceGraficaInterface, texto: string): ComponenteInterfaceGraficaInterface {
+        const elementoPai = this.obterElemento(pai);
+        const rotulo = document.createElement('label');
+        rotulo.textContent = texto;
+        Object.assign(rotulo.style, {
+            fontSize: '13px',
+            color: '#222',
+        });
+        elementoPai.appendChild(rotulo);
+        return this.registrar(rotulo);
+    }
+
+    criarCaixaTexto(pai: ComponenteInterfaceGraficaInterface, textoInicial: string): ComponenteInterfaceGraficaInterface {
+        const elementoPai = this.obterElemento(pai);
+        const entrada = document.createElement('input');
+        entrada.type = 'text';
+        entrada.value = textoInicial;
+        Object.assign(entrada.style, {
+            fontSize: '13px',
+            padding: '5px 8px',
+            border: '1px solid #999',
+            borderRadius: '3px',
+            boxSizing: 'border-box',
+        });
+        elementoPai.appendChild(entrada);
+        return this.registrar(entrada);
+    }
+
+    criarCaixaVertical(pai: ComponenteInterfaceGraficaInterface): ComponenteInterfaceGraficaInterface {
+        const elementoPai = this.obterElemento(pai);
+        const caixa = document.createElement('div');
+        Object.assign(caixa.style, {
+            display: 'flex',
+            flexDirection: 'column',
+            gap: '8px',
+        });
+        elementoPai.appendChild(caixa);
+        return this.registrar(caixa);
+    }
+
+    criarCaixaHorizontal(pai: ComponenteInterfaceGraficaInterface): ComponenteInterfaceGraficaInterface {
+        const elementoPai = this.obterElemento(pai);
+        const caixa = document.createElement('div');
+        Object.assign(caixa.style, {
+            display: 'flex',
+            flexDirection: 'row',
+            gap: '8px',
+            alignItems: 'center',
+        });
+        elementoPai.appendChild(caixa);
+        return this.registrar(caixa);
+    }
+
+    // -------------------------------------------------------------------------
+    // Leitura e escrita de propriedades
+    // -------------------------------------------------------------------------
+
+    definirTexto(componente: ComponenteInterfaceGraficaInterface, texto: string): void {
+        const elemento = this.obterElemento(componente);
+        if (elemento instanceof HTMLInputElement || elemento instanceof HTMLTextAreaElement) {
+            elemento.value = texto;
+        } else {
+            elemento.textContent = texto;
+        }
+    }
+
+    obterTexto(componente: ComponenteInterfaceGraficaInterface): string {
+        const elemento = this.obterElemento(componente);
+        if (elemento instanceof HTMLInputElement || elemento instanceof HTMLTextAreaElement) {
+            return elemento.value;
+        }
+        return elemento.textContent ?? '';
+    }
+
+    // -------------------------------------------------------------------------
+    // Eventos
+    // -------------------------------------------------------------------------
+
+    conectarEvento(
+        componente: ComponenteInterfaceGraficaInterface,
+        evento: string,
+        callback: (...argumentos: any[]) => Promise<void>
+    ): void {
+        const elemento = this.obterElemento(componente);
+        const eventoDOM = MAPA_EVENTOS[evento] ?? evento;
+
+        elemento.addEventListener(eventoDOM, (e: Event) => {
+            // Para o evento 'alterado' em campos de texto, passa o valor atual.
+            // Para demais eventos, não passa argumentos ao callback.
+            if (
+                evento === 'alterado' &&
+                (elemento instanceof HTMLInputElement || elemento instanceof HTMLTextAreaElement)
+            ) {
+                callback(elemento.value).catch(console.error);
+            } else {
+                callback().catch(console.error);
+            }
+        });
+    }
+
+    // -------------------------------------------------------------------------
+    // Ciclo de vida
+    // -------------------------------------------------------------------------
+
+    async iniciarLaco(): Promise<void> {
+        return new Promise<void>((resolve) => {
+            this.resolverLaco = resolve;
+        });
+    }
+
+    encerrar(): void {
+        if (this.sobreposicao?.parentNode) {
+            this.sobreposicao.parentNode.removeChild(this.sobreposicao);
+            this.sobreposicao = null;
+        }
+        this.elementosPorId.clear();
+
+        if (this.resolverLaco) {
+            this.resolverLaco();
+            this.resolverLaco = null;
+        }
+    }
+}

package/fontes/infraestruturas/index.ts

@@ -0,0 +1,2 @@
+export * from './electron/infraestrutura-electron';
+export * from './vazia/infraestrutura-vazia';

package/fontes/infraestruturas/vazia/README.md

@@ -0,0 +1,53 @@
+# InfraestruturaVazia
+
+Implementação de `InfraestruturaGraficaInterface` sem operações visuais. Nenhum elemento
+DOM é criado e nenhuma janela é exibida. Destinada exclusivamente a **testes unitários** e
+a ambientes sem interface gráfica (CI, Node.js puro).
+
+## Comportamento
+
+### Criação de componentes
+
+Todos os métodos `criar*` retornam objetos `ComponenteInterfaceGraficaInterface` com IDs
+únicos gerados por um contador de instância (e.g. `componente-1`, `componente-2`, …).
+Parâmetros como `pai`, `largura`, `altura` e `titulo` são ignorados.
+
+### Estado de texto
+
+`criarRotulo` e `criarCaixaTexto` armazenam o texto inicial em um
+`Map<string, string>` indexado pelo `idComponente`. `definirTexto` atualiza essa entrada;
+`obterTexto` a lê (retorna `''` caso o componente não tenha texto registrado).
+
+Componentes que não carregam texto (janela, botão, caixas de layout) não têm entrada no
+mapa — `obterTexto` devolve `''` para eles.
+
+### Eventos
+
+`conectarEvento` aceita o registro sem lançar exceção, mas descarta o callback. Nenhum
+evento é disparado internamente.
+
+### Ciclo de vida
+
+| Método        | Comportamento                          |
+|---------------|----------------------------------------|
+| `iniciarLaco` | Resolve imediatamente (`async` vazio). |
+| `encerrar`    | Não faz nada.                          |
+
+## Uso em testes
+
+```typescript
+import { InfraestruturaVazia } from './infraestrutura-vazia';
+import { InterfaceGrafica } from '../../interface-grafica';
+
+const infraestrutura = new InfraestruturaVazia();
+const ig = new InterfaceGrafica(infraestrutura);
+
+const janela = ig.janela(interpretador, 800, 600, 'Teste');
+const rotulo = ig.rotulo(interpretador, janela, 'Olá');
+
+ig.definirTexto(interpretador, rotulo, 'Mundo');
+expect(ig.obterTexto(interpretador, rotulo)).toBe('Mundo');
+```
+
+Crie uma nova instância de `InfraestruturaVazia` em cada `beforeEach` para evitar
+vazamento de estado entre testes.

package/fontes/infraestruturas/vazia/infraestrutura-vazia.ts

@@ -0,0 +1,61 @@
+import { InfraestruturaGraficaInterface } from '../../interfaces/infraestrutura-grafica-interface';
+import { ComponenteInterfaceGraficaInterface } from '../../interfaces/componente-interface-grafica-interface';
+
+/**
+ * Infraestrutura sem operações: não cria janelas nem elementos visuais.
+ * Útil para testes unitários e ambientes sem interface gráfica.
+ */
+export class InfraestruturaVazia implements InfraestruturaGraficaInterface {
+    private contadorIds = 0;
+    private textos: Map<string, string> = new Map();
+
+    private novoComponente(): ComponenteInterfaceGraficaInterface {
+        return { idComponente: `componente-${++this.contadorIds}` };
+    }
+
+    criarJanela(_largura: number, _altura: number, _titulo: string): ComponenteInterfaceGraficaInterface {
+        return this.novoComponente();
+    }
+
+    criarBotao(_pai: ComponenteInterfaceGraficaInterface, _rotulo: string): ComponenteInterfaceGraficaInterface {
+        return this.novoComponente();
+    }
+
+    criarRotulo(_pai: ComponenteInterfaceGraficaInterface, texto: string): ComponenteInterfaceGraficaInterface {
+        const componente = this.novoComponente();
+        this.textos.set(componente.idComponente, texto);
+        return componente;
+    }
+
+    criarCaixaTexto(_pai: ComponenteInterfaceGraficaInterface, textoInicial: string): ComponenteInterfaceGraficaInterface {
+        const componente = this.novoComponente();
+        this.textos.set(componente.idComponente, textoInicial);
+        return componente;
+    }
+
+    criarCaixaVertical(_pai: ComponenteInterfaceGraficaInterface): ComponenteInterfaceGraficaInterface {
+        return this.novoComponente();
+    }
+
+    criarCaixaHorizontal(_pai: ComponenteInterfaceGraficaInterface): ComponenteInterfaceGraficaInterface {
+        return this.novoComponente();
+    }
+
+    definirTexto(componente: ComponenteInterfaceGraficaInterface, texto: string): void {
+        this.textos.set(componente.idComponente, texto);
+    }
+
+    obterTexto(componente: ComponenteInterfaceGraficaInterface): string {
+        return this.textos.get(componente.idComponente) ?? '';
+    }
+
+    conectarEvento(
+        _componente: ComponenteInterfaceGraficaInterface,
+        _evento: string,
+        _callback: (...argumentos: any[]) => Promise<void>
+    ): void {}
+
+    async iniciarLaco(): Promise<void> {}
+
+    encerrar(): void {}
+}

package/fontes/interface-grafica.ts

@@ -0,0 +1,172 @@
+import { InterpretadorInterface } from '@designliquido/delegua';
+import { InfraestruturaGraficaInterface } from './interfaces/infraestrutura-grafica-interface';
+import { ComponenteInterfaceGraficaInterface } from './interfaces/componente-interface-grafica-interface';
+
+/**
+ * Biblioteca de interface gráfica para Delégua.
+ *
+ * Cada método público recebe o interpretador como primeiro argumento
+ * porque são registrados como `FuncaoPadrao`, que repassa o visitante
+ * automaticamente. Os argumentos seguintes são os fornecidos pelo código Delégua.
+ */
+export class InterfaceGrafica {
+    constructor(private readonly backend: InfraestruturaGraficaInterface) {}
+
+    /**
+     * Cria a janela principal do programa.
+     * @param interpretador Passado automaticamente pelo interpretador Delégua.
+     * @param largura Largura em pixels.
+     * @param altura Altura em pixels.
+     * @param titulo Título exibido na barra da janela.
+     */
+    janela(
+        _interpretador: InterpretadorInterface,
+        largura: number,
+        altura: number,
+        titulo: string
+    ): ComponenteInterfaceGraficaInterface {
+        return this.backend.criarJanela(largura, altura, titulo);
+    }
+
+    /**
+     * Cria um botão dentro do componente pai.
+     * @param interpretador Passado automaticamente pelo interpretador Delégua.
+     * @param pai Componente que conterá o botão.
+     * @param rotulo Texto exibido no botão.
+     */
+    botao(
+        _interpretador: InterpretadorInterface,
+        pai: ComponenteInterfaceGraficaInterface,
+        rotulo: string
+    ): ComponenteInterfaceGraficaInterface {
+        return this.backend.criarBotao(pai, rotulo);
+    }
+
+    /**
+     * Cria um rótulo de texto dentro do componente pai.
+     * @param interpretador Passado automaticamente pelo interpretador Delégua.
+     * @param pai Componente que conterá o rótulo.
+     * @param texto Texto exibido.
+     */
+    rotulo(
+        _interpretador: InterpretadorInterface,
+        pai: ComponenteInterfaceGraficaInterface,
+        texto: string
+    ): ComponenteInterfaceGraficaInterface {
+        return this.backend.criarRotulo(pai, texto);
+    }
+
+    /**
+     * Cria uma caixa de texto editável dentro do componente pai.
+     * @param interpretador Passado automaticamente pelo interpretador Delégua.
+     * @param pai Componente que conterá a caixa de texto.
+     * @param textoInicial Valor inicial da caixa.
+     */
+    caixaTexto(
+        _interpretador: InterpretadorInterface,
+        pai: ComponenteInterfaceGraficaInterface,
+        textoInicial: string = ''
+    ): ComponenteInterfaceGraficaInterface {
+        return this.backend.criarCaixaTexto(pai, textoInicial ?? '');
+    }
+
+    /**
+     * Cria um contêiner com layout vertical (empilhamento de cima para baixo).
+     * @param interpretador Passado automaticamente pelo interpretador Delégua.
+     * @param pai Componente pai do contêiner.
+     */
+    caixaVertical(
+        _interpretador: InterpretadorInterface,
+        pai: ComponenteInterfaceGraficaInterface
+    ): ComponenteInterfaceGraficaInterface {
+        return this.backend.criarCaixaVertical(pai);
+    }
+
+    /**
+     * Cria um contêiner com layout horizontal (empilhamento da esquerda para direita).
+     * @param interpretador Passado automaticamente pelo interpretador Delégua.
+     * @param pai Componente pai do contêiner.
+     */
+    caixaHorizontal(
+        _interpretador: InterpretadorInterface,
+        pai: ComponenteInterfaceGraficaInterface
+    ): ComponenteInterfaceGraficaInterface {
+        return this.backend.criarCaixaHorizontal(pai);
+    }
+
+    /**
+     * Altera o texto de um componente (rótulo ou caixa de texto).
+     * @param interpretador Passado automaticamente pelo interpretador Delégua.
+     * @param componente Componente a ser alterado.
+     * @param texto Novo texto.
+     */
+    definirTexto(
+        _interpretador: InterpretadorInterface,
+        componente: ComponenteInterfaceGraficaInterface,
+        texto: string
+    ): void {
+        this.backend.definirTexto(componente, texto);
+    }
+
+    /**
+     * Lê o texto atual de um componente (rótulo ou caixa de texto).
+     * @param interpretador Passado automaticamente pelo interpretador Delégua.
+     * @param componente Componente a ser lido.
+     */
+    obterTexto(
+        _interpretador: InterpretadorInterface,
+        componente: ComponenteInterfaceGraficaInterface
+    ): string {
+        return this.backend.obterTexto(componente);
+    }
+
+    /**
+     * Registra uma função Delégua para ser chamada ao clicar no componente.
+     * @param interpretador Passado automaticamente pelo interpretador Delégua.
+     * @param componente Componente que receberá o evento.
+     * @param funcaoDelegua Função declarada em Delégua a ser invocada no clique.
+     */
+    aoClicar(
+        interpretador: InterpretadorInterface,
+        componente: ComponenteInterfaceGraficaInterface,
+        funcaoDelegua: any
+    ): void {
+        this.backend.conectarEvento(componente, 'clique', async () => {
+            await interpretador.executarChamavel(funcaoDelegua, []);
+        });
+    }
+
+    /**
+     * Registra uma função Delégua para ser chamada quando o texto do componente mudar.
+     * @param interpretador Passado automaticamente pelo interpretador Delégua.
+     * @param componente Componente que receberá o evento.
+     * @param funcaoDelegua Função declarada em Delégua a ser invocada na mudança.
+     */
+    aoAlterar(
+        interpretador: InterpretadorInterface,
+        componente: ComponenteInterfaceGraficaInterface,
+        funcaoDelegua: any
+    ): void {
+        this.backend.conectarEvento(componente, 'alterado', async (novoTexto: string) => {
+            await interpretador.executarChamavel(funcaoDelegua, [novoTexto]);
+        });
+    }
+
+    /**
+     * Inicia o laço de eventos da interface gráfica. Este método bloqueia
+     * a execução do programa Delégua até que a janela seja fechada.
+     * Deve ser chamado após criar e configurar todos os componentes.
+     * @param interpretador Passado automaticamente pelo interpretador Delégua.
+     */
+    async iniciar(_interpretador: InterpretadorInterface): Promise<void> {
+        await this.backend.iniciarLaco();
+    }
+
+    /**
+     * Encerra a interface gráfica e fecha todas as janelas.
+     * @param interpretador Passado automaticamente pelo interpretador Delégua.
+     */
+    encerrar(_interpretador: InterpretadorInterface): void {
+        this.backend.encerrar();
+    }
+}

package/fontes/interfaces/componente-interface-grafica-interface.ts

@@ -0,0 +1,8 @@
+/**
+ * Identificador opaco de um componente de interface gráfica.
+ * Delégua recebe e devolve este objeto às funções da biblioteca.
+ * Cada infraestrutura é responsável por implementar e interpretar o conteúdo interno.
+ */
+export interface ComponenteInterfaceGraficaInterface {
+    readonly idComponente: string;
+}

package/fontes/interfaces/index.ts

@@ -0,0 +1,2 @@
+export * from './infraestrutura-grafica-interface';
+export * from './componente-interface-grafica-interface';

package/fontes/interfaces/infraestrutura-grafica-interface.ts

@@ -0,0 +1,46 @@
+import { ComponenteInterfaceGraficaInterface } from './componente-interface-grafica-interface';
+
+/**
+ * Contrato que todo infraestrutura de interface gráfica deve implementar.
+ * O infraestrutura é responsável por criar e manipular os elementos visuais
+ * no ambiente de execução (Electron, navegador, etc.).
+ *
+ * As chamadas de eventos recebem um callback já resolvido: o backend
+ * não precisa conhecer o interpretador nem os tipos de Delégua.
+ */
+export interface InfraestruturaGraficaInterface {
+    // Criação de componentes
+    criarJanela(largura: number, altura: number, titulo: string): ComponenteInterfaceGraficaInterface;
+    criarBotao(pai: ComponenteInterfaceGraficaInterface, rotulo: string): ComponenteInterfaceGraficaInterface;
+    criarRotulo(pai: ComponenteInterfaceGraficaInterface, texto: string): ComponenteInterfaceGraficaInterface;
+    criarCaixaTexto(pai: ComponenteInterfaceGraficaInterface, textoInicial: string): ComponenteInterfaceGraficaInterface;
+    criarCaixaVertical(pai: ComponenteInterfaceGraficaInterface): ComponenteInterfaceGraficaInterface;
+    criarCaixaHorizontal(pai: ComponenteInterfaceGraficaInterface): ComponenteInterfaceGraficaInterface;
+
+    // Leitura e escrita de propriedades
+    definirTexto(componente: ComponenteInterfaceGraficaInterface, texto: string): void;
+    obterTexto(componente: ComponenteInterfaceGraficaInterface): string;
+
+    /**
+     * Registra um callback nativo a ser invocado quando o evento ocorrer.
+     * O callback já encapsula a chamada ao interpretador de Delégua,
+     * portanto o infraestrutura só precisa chamá-lo no momento certo.
+     * @param componente O componente-alvo do evento.
+     * @param evento Nome do evento: 'clique', 'alterado', 'tecla', etc.
+     * @param callback Função assíncrona a ser chamada quando o evento ocorrer.
+     */
+    conectarEvento(
+        componente: ComponenteInterfaceGraficaInterface,
+        evento: string,
+        callback: (...argumentos: any[]) => Promise<void>
+    ): void;
+
+    /**
+     * Inicia o laço de eventos. Resolve quando a janela principal for fechada
+     * ou quando `encerrar()` for chamado.
+     */
+    iniciarLaco(): Promise<void>;
+
+    /** Encerra o laço de eventos e fecha todas as janelas. */
+    encerrar(): void;
+}

package/jest.config.ts

@@ -0,0 +1,21 @@
+import type { Config } from '@jest/types';
+
+export default async (): Promise<Config.InitialOptions> => {
+    return {
+        verbose: true,
+        modulePathIgnorePatterns: ['<rootDir>/dist/'],
+        preset: 'ts-jest',
+        testEnvironment: 'node',
+        transform: {
+            '^.+\\.tsx?$': ['ts-jest', {
+                isolatedModules: false,
+                tsconfig: {
+                    sourceMap: true,
+                    inlineSourceMap: true,
+                    inlineSources: true
+                }
+            }]
+        },
+        coverageReporters: ['json-summary', 'lcov', 'text', 'text-summary']
+    };
+};