liquido/liquido.d.ts

Conjunto de ferramentas para desenvolvimento de aplicações para a internet 100% em português

import { AvaliadorSintaticoComImportacao } from '@designliquido/delegua-node/avaliador-sintatico/avaliador-sintatico-com-importacao';
import { Construto, FuncaoConstruto } from '@designliquido/delegua/construtos';
import { InterpretadorInterface, RetornoInterpretador } from '@designliquido/delegua/interfaces';
import { Importador } from '@designliquido/delegua-node/importador';
import { FolEs } from '@designliquido/foles';
import { FormatadorLmht } from './infraestrutura/formatadores';
import { ProvedorLincones } from './infraestrutura/provedores';
import { Roteador } from './infraestrutura/roteador';
import { LiquidoInterface, RetornoConfiguracaoInterface } from './interfaces';
import { CentroConfiguracoes } from './infraestrutura/centro-configuracoes';
import { AutoDocumentador } from './infraestrutura/auto-documentacao/auto-documentador';
/**
 * O núcleo do framework.
 */
export declare class Liquido implements LiquidoInterface {
    importador: Importador;
    avaliadorSintatico: AvaliadorSintaticoComImportacao;
    interpretador: InterpretadorInterface;
    roteador: Roteador;
    formatadorLmht: FormatadorLmht;
    provedorLincones: ProvedorLincones;
    foles: FolEs;
    centroConfiguracoes: CentroConfiguracoes;
    autoDocumentador: AutoDocumentador;
    arquivosDelegua: string[];
    rotasDelegua: string[];
    diretorioBase: string;
    diretorioDescobertos: string[];
    diretorioEstatico: string;
    arquivosAbertos: {
        [identificador: string]: string;
    };
    conteudoArquivosAbertos: {
        [identificador: string]: string[];
    };
    constructor(diretorioBase: string);
    iniciar(): Promise<void>;
    /**
     * Método de importação do arquivo `configuracao.delegua`.
     * @returns void.
     */
    importarArquivoConfiguracao(): void;
    /**
     * Retorna o caminho do arquivo de configuração se existir.
     * @param {string} caminhoTotal O caminho para o diretório a ser pesquisado.
     * @returns Um objeto com duas propriedades: `caminho` e `valor`. Se o caminho foi
     *          encontrado, `valor` será `true`, e `caminho` terá o caminho completo
     *          do arquivo de configuração. Caso contrário, `valor` será `false`, e
     *          `caminho` será nulo.
     */
    resolverArquivoConfiguracao(caminhoTotal?: string): RetornoConfiguracaoInterface;
    /**
     * Método de descoberta de rotas. Recursivo.
     * @param diretorio O diretório a ser pesquisado.
     */
    descobrirRotas(diretorio: string): void;
    descobrirEstilos(): string[];
    escreverEstilos(): void;
    /**
     * Ele pega um caminho de arquivo e retorna uma rota
     * @param {string} caminhoArquivo O caminho do arquivo que está sendo lido
     * @returns A rota resolvida.
     */
    resolverCaminhoRota(caminhoArquivo: string): string;
    importarArquivosRotas(): Promise<void>;
    /**
     * O Interpretador Delégua exige alguns parâmetros definidos antes de executar.
     * Esse método define esses parâmetros na posição inicial da pilha de execução
     * do Interpretador.
     * @param requisicao O objeto de requisição do Express.
     * @param nomeFuncao O nome da função a ser chamada pelo Interpretador.
     * @param funcaoConstruto O conteúdo da função, declarada no arquivo `.delegua` correspondente.
     */
    prepararRequisicao(requisicao: any, nomeFuncao: string, funcaoConstruto: FuncaoConstruto): Promise<void>;
    /**
     * Chamada ao Interpretador Delégua com a estrutura declarativa para a
     * execução da função nomeada na rota.
     * @param nomeFuncao O nome da função da rota.
     * @returns O resultado da interpretação.
     */
    chamarInterpretador(nomeFuncao: string): Promise<RetornoInterpretador>;
    private logicaComumErrosInterpretacao;
    private logicaComumResultadoInterpretador;
    /**
     * Configuração de uma rota no roteador Express.
     * @param metodoRoteador O método da rota.
     * @param caminhoRota O caminho completo do arquivo que define a rota.
     * @param argumentos Todas as funções em Delégua que devem ser executadas
     *                   para a resolução da rota. Por enquanto apenas a primeira
     *                   função é executada.
     */
    adicionarRota(metodoRoteador: string, caminhoRota: string, argumentos: Construto[]): Promise<void>;
}