liquido/liquido.d.ts

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

import { AvaliadorSintaticoLiquido, AvaliadorSintaticoLiquidoPitugues } from './infraestrutura/avaliadores-sintaticos';
import { FuncaoConstruto } from '@designliquido/delegua/construtos';
import { InterpretadorInterface, RetornoInterpretadorInterface } 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';
import { Declaracao } from '@designliquido/foles/declaracoes';
/**
 * O núcleo do framework.
 */
export declare class Liquido implements LiquidoInterface {
    importador: Importador | undefined;
    avaliadorSintatico: AvaliadorSintaticoLiquido | AvaliadorSintaticoLiquidoPitugues | undefined;
    interpretador: InterpretadorInterface | undefined;
    roteador: Roteador;
    formatadorLmht: FormatadorLmht;
    provedorLincones: ProvedorLincones;
    foles: FolEs;
    centroConfiguracoes: CentroConfiguracoes;
    autoDocumentador: AutoDocumentador;
    private classeContextoEntidades;
    arquivosDelegua: string[];
    arquivosPitugues: string[];
    rotasDelegua: string[];
    rotasPitugues: string[];
    diretorioBase: string;
    diretorioDescobertos: string[];
    diretorioEstatico: string;
    arquivosAbertos: {
        [identificador: string]: string;
    };
    conteudoArquivosAbertos: {
        [identificador: string]: string[];
    };
    constructor(diretorioBase: string);
    iniciar(): Promise<void>;
    private configurarPipelineLinguagem;
    /**
     * Método de importação do arquivo `configuracao.delprops`.
     * @returns void.
     */
    importarArquivoConfiguracao(): Promise<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;
    private normalizarLinguagem;
    /**
     * Método de descoberta de rotas. Recursivo.
     * @param diretorio O diretório a ser pesquisado.
     */
    descobrirRotas(diretorio: string, linguagem: string): void;
    descobrirEstilos(): string[];
    /**
     * Diretório onde o CSS gerado a partir de FolEs é escrito e a partir
     * do qual é servido pelo Express (`liquido.estilos.diretorioBase`, padrão: 'publico/css').
     */
    obterDiretorioBaseEstilos(): 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, linguagem: string): string;
    analisarArquivo(arquivo: string): Promise<Declaracao[] | null>;
    private coletarFuncoesDaRota;
    private resolverArgumentosDaRota;
    private extrairChamadaLiquido;
    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<RetornoInterpretadorInterface>;
    private classificarErro;
    private logicaComumErrosInterpretacao;
    /**
     * Lógica para processamento da resposta como uma visão LMHT.
     * @param caminhoRota O caminho da rota da requisição.
     * @param statusHttp O status HTTP pré-calculado.
     * @param propriedades Propriedades da resposta, usadas para escolher a visão e parametrizá-la.
     * @returns Um objeto com o corpo do retorno e o status HTTP correspondente.
     */
    private logicaComumRespostaVisaoLmht;
    private obterObjetoRespostaDoEscopo;
    private processarPropriedadesResposta;
    private logicaComumResultadoInterpretador;
    /**
     * Verifica se uma resposta foi definida pelo middleware ou handler.
     * @param corpoEStatus O objeto de resposta retornado pelo interpretador.
     * @returns Verdadeiro se alguma resposta foi definida, falso caso contrário.
     */
    private respostaFoiDefinida;
    /**
     * Executa uma função (middleware ou handler) no contexto do interpretador.
     * @param req O objeto de requisição do Express.
     * @param caminhoRota O caminho da rota.
     * @param funcao A função a ser executada.
     * @param nomeFuncao O nome único para identificar a função no interpretador.
     * @returns O corpo e status da resposta, se houver.
     */
    private executarFuncaoRota;
    /**
     * 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. O último argumento é o handler final,
     *                   todos os anteriores são middlewares executados em sequência.
     */
    adicionarRota(metodoRoteador: string, caminhoRota: string, argumentos: FuncaoConstruto[]): Promise<void>;
    private limparObjeto;
}