liquido
Version:
Conjunto de ferramentas para desenvolvimento de aplicações para a internet 100% em português
184 lines • 8.81 kB
JavaScript
;
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function (o) {
var ar = [];
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__setModuleDefault(result, mod);
return result;
};
})();
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.FormatadorLmht = void 0;
const sistemaDeArquivos = __importStar(require("fs"));
const caminho = __importStar(require("path"));
const handlebars_1 = __importDefault(require("handlebars"));
const lmht_js_1 = require("@designliquido/lmht-js");
const preprocessadores_1 = require("../preprocessadores");
class FormatadorLmht {
constructor(diretorioBase) {
this.regexParcial = /<parcial nome="([^"]+)".*?(?:\/>|><\/parcial>)/g;
this.conversorLmht = new lmht_js_1.ConversorLmht();
this.preprocessadorFolEs = new preprocessadores_1.PreprocessadorFolEs();
this.preprocessadorHandlebars = new preprocessadores_1.PreprocessadorHandlebars();
this.preprocessadorLmhtParciais = new preprocessadores_1.PreprocessadorLmhtParciais();
this.diretorioBase = diretorioBase;
}
/**
* Aplica transformações Handlebars e LMHT no arquivo de visão correspondente
* à rota.
* @param caminhoRota Caminho da rota na requisição.
* @param valores Valores que devem ser usados na aplicação do Handlebars.
* @returns O resultado das duas conversões.
*/
async formatar(caminhoRota, valores) {
const resolucaoVisao = this.resolverVisaoCorrespondente(caminhoRota);
if (!resolucaoVisao.visaoCorrespondente) {
let listaCaminhosTentados = 'Caminhos tentados: ';
for (const caminhoTentado of resolucaoVisao.caminhosTentados) {
listaCaminhosTentados += caminhoTentado + '; ';
}
return Promise.reject(`Visão correspondente à rota ${caminhoRota} não existe. ${listaCaminhosTentados}`);
}
const arquivoBase = sistemaDeArquivos.readFileSync(resolucaoVisao.visaoCorrespondente);
const conteudoDoArquivo = arquivoBase.toString();
let textoBase = conteudoDoArquivo;
if (valores) {
// Preprocessamento: Parciais
const parciaisResolvidas = [];
let parciais = [];
if (this.verificarEstruturaParcial(textoBase)) {
parciais = this.devolverParciais(textoBase);
const textoParcial = parciais.map((parcial) => {
return `<lmht><corpo>${parcial}</corpo></lmht>`;
});
textoParcial.map((parcial) => {
const result = this.preprocessadorLmhtParciais.processarParciais(parcial);
if (result instanceof Error) {
throw result;
}
parciaisResolvidas.push(result.conteudo);
});
}
textoBase = this.formatarTextoBase(textoBase, parciais, parciaisResolvidas);
// Preprocessamento: Handlebars
textoBase = this.preprocessadorHandlebars.processar(textoBase);
const template = handlebars_1.default.compile(textoBase);
const valoresResolvidos = this.resolverValores(valores);
textoBase = template(valoresResolvidos);
}
// Preprocessamento: FolEs
textoBase = await this.preprocessadorFolEs.processar(textoBase);
return this.conversorLmht.converterPorTexto(textoBase);
}
resolverVisaoCorrespondente(caminhoRota) {
const caminhoRotaParametrosResolvidos = caminhoRota.replace(/:([\w]+)(\/)?/i, `[$1]`);
const diretorioOuArquivo = caminho.join(this.diretorioBase, 'visoes', caminhoRotaParametrosResolvidos);
const retorno = {
visaoCorrespondente: '',
caminhosTentados: [
diretorioOuArquivo,
diretorioOuArquivo + '.lmht'
]
};
let visaoCorrespondente;
if (caminhoRotaParametrosResolvidos.endsWith(']')) {
// Quando o caminho termina em um símbolo de parâmetro, significa que a visão correspondente
// é a de detalhes.
const caminhoRotaDiretorio = caminhoRota.replace(/:([\w]+)(\/)?/i, '');
visaoCorrespondente = caminho.join(this.diretorioBase, 'visoes', caminhoRotaDiretorio, 'detalhes.lmht');
}
else {
visaoCorrespondente = caminho.join(this.diretorioBase, 'visoes', caminhoRotaParametrosResolvidos + '.lmht');
}
if (sistemaDeArquivos.existsSync(diretorioOuArquivo)) {
// É diretório
if (visaoCorrespondente.endsWith(caminho.sep + '.lmht')) {
visaoCorrespondente = visaoCorrespondente.replace(caminho.sep + '.lmht', caminho.sep + 'inicial.lmht');
}
}
if (!sistemaDeArquivos.existsSync(visaoCorrespondente)) {
// Caminho não existe.
// Se o caminho não termina com `inicial.lmht`, testar existência.
// Se não existir, visão correspondente passa a ser a `inicial.lmht`.
visaoCorrespondente = caminho.join(diretorioOuArquivo, 'inicial.lmht');
retorno.caminhosTentados.push(visaoCorrespondente);
if (!sistemaDeArquivos.existsSync(visaoCorrespondente)) {
// Se ainda assim visão correspondente não existir, indefinir para erro borbulhar
// nas chamadas superiores.
visaoCorrespondente = undefined;
}
}
retorno.visaoCorrespondente = visaoCorrespondente;
return retorno;
}
/**
* Resolve valores para o Handlebars, já que alguns objetos retornados pelo núcleo de
* Delégua não são exatamente dicionários.
* @param valores Os valores a serem enviados para o Handlebars.
* @returns Todos os valores normalizados como dicionários, ou ainda dicionários de dicionários.
*/
resolverValores(valores) {
const valoresResolvidos = {};
for (const [nome, valor] of Object.entries(valores)) {
// eslint-disable-next-line no-prototype-builtins
let valorResolvido = valor.hasOwnProperty('valor') ? valor.valor : valor;
if (valorResolvido.constructor.name === 'ObjetoDeleguaClasse') {
valorResolvido = this.obterPropriedadesDeObjetoComoDicionario(valorResolvido);
}
valoresResolvidos[nome] = valorResolvido;
}
return valoresResolvidos;
}
obterPropriedadesDeObjetoComoDicionario(objeto) {
const dicionarioPropriedades = {};
for (const [nome, valor] of Object.entries(objeto.propriedades)) {
dicionarioPropriedades[nome] = valor;
}
return dicionarioPropriedades;
}
formatarTextoBase(textoBase, listaDeParciais, parciaisResolvidos) {
for (let i = 0; i < listaDeParciais.length; i++) {
textoBase = textoBase.replace(listaDeParciais[i], parciaisResolvidos[i]);
}
return textoBase;
}
devolverParciais(textoLmht) {
return textoLmht.match(this.regexParcial).map((parcial) => {
return parcial.toString();
});
}
verificarEstruturaParcial(textoLmht) {
const matches = textoLmht.match(this.regexParcial);
return (matches === null || matches === void 0 ? void 0 : matches.length) > 0 ? true : false;
}
}
exports.FormatadorLmht = FormatadorLmht;
//# sourceMappingURL=formatador-lmht.js.map