500 lines
19 KiB
JavaScript
500 lines
19 KiB
JavaScript
Mapeate = function(entradas){
|
|
|
|
const self = this,
|
|
configuracion_por_defecto = {
|
|
nulos : false,
|
|
valor_por_defecto : null,
|
|
autoiniciar : true,
|
|
archivos_de_configuracion_por_defecto : [
|
|
"/json/Mapeate.configuracion.json",
|
|
"/json/Mapeate.configuracion.secretos.json"
|
|
],
|
|
texto_por_defecto : "",
|
|
configuracion_sobreescribir : false,
|
|
i18n_sobreescribir : false,
|
|
formato_terminal : "[{tipo}] {yyyy}{mm}{dd} {hh}{ii}{ss} [{linea}]{archivo}({metodo}): {mensaje}",
|
|
terminal_tipos_por_defecto : [
|
|
["unkn", "unknown", "desconocido"],
|
|
[" ok ", "ok", "si", "correcto"],
|
|
["info", "informacion", "information"],
|
|
["note", "nota", "comment", "comentario"],
|
|
["warn", "warning", "aviso", "advertencia"],
|
|
["erro", "error", "incrrecto"],
|
|
["fail", "failure", "fallo"],
|
|
["exce", "excepcion"]
|
|
],
|
|
archivos_de_i18n_por_defecto : [
|
|
"/json/i18n/Mapeate.i18n.espanol.json"
|
|
],
|
|
ajax_timeout : 2000
|
|
},
|
|
configuracion = {},
|
|
textos = {},
|
|
terminal_tipos = [];
|
|
let iniciado = false,
|
|
configuracion_sobreescribir = false,
|
|
idioma_por_defecto = null,
|
|
idioma = null,
|
|
modo_dispositivo = "por_defecto",
|
|
modo_gui = "por_defecto",
|
|
terminal_unkn_oscuro, terminal_unkn_claro,
|
|
terminal_ok_oscuro, terminal_ok_claro,
|
|
terminal_info_oscuro, terminal_info_claro,
|
|
terminal_note_oscuro, terminal_note_claro,
|
|
modo_gui_oscuro = window.matchMedia && window.matchMedia("(prefers-color-scheme: dark)").matches,
|
|
formato_terminal = "[{tipo}] {yyyy}{mm}{dd} {hh}{ii}{ss} [{linea}]{archivo}({metodo}): {mensaje}";
|
|
|
|
const re_bloque_de_traza = new RegExp("^(" + [
|
|
/\s*at\s+(([^\s]+)\s+\()?(([^\(\)\:]+\:)?[^\(\)\:]+)(\:([0-9]+)\:[0-9]+)?\)?/.source, // Webkit
|
|
/([^\@]+)\@([^:]+\:[^\:]+)\:([0-9]+)\:[0-9]+/.source, // Gecko
|
|
].join("|") + ")$")
|
|
|
|
const constructor = () => {
|
|
|
|
configuracion_por_defecto.terminal_tipos_por_defecto.forEach(entrada => terminal_tipos.push(entrada));
|
|
|
|
self.print("info", "mapeate_construyendose");
|
|
|
|
self.configuracion("autoiniciar") && self.iniciar(() => {
|
|
self.print("ok", "mapeate_construido");
|
|
});
|
|
|
|
};
|
|
|
|
const establecer_variables_comunes = () => {
|
|
|
|
configuracion_sobreescribir = self.configuracion(["configuracion_sobreescribir", "sobreescribir"]);
|
|
formato_terminal = self.configuracion("formato_terminal");
|
|
|
|
terminal_unkn_oscuro = self.configuracion("terminal_unkn_oscuro");
|
|
terminal_unkn_claro = self.configuracion("terminal_ounkn_claro");
|
|
terminal_ok_oscuro = self.configuracion("terminal_ok_oscuro");
|
|
terminal_ok_claro = self.configuracion("terminal_ok_claro");
|
|
terminal_info_oscuro = self.configuracion("terminal_info_oscuro");
|
|
terminal_info_claro = self.configuracion("terminal_info_claro");
|
|
terminal_note_oscuro = self.configuracion("terminal_note_oscuro");
|
|
terminal_note_claro = self.configuracion("terminal_note_claro");
|
|
|
|
};
|
|
|
|
this.iniciar = callback => {
|
|
|
|
const terminar = estado => typeof callback == "function" && callback(estado);
|
|
|
|
if(iniciado){
|
|
terminar(false);
|
|
return false;
|
|
};
|
|
iniciado = true;
|
|
|
|
establecer_variables_comunes();
|
|
|
|
self.configuracion_anadir(self.configuracion("archivos_de_configuracion_por_defecto"), null, () => {
|
|
establecer_variables_comunes();
|
|
self.configuracion_anadir(self.configuracion("archivos_de_configuracion"), null, () => {
|
|
establecer_variables_comunes();
|
|
self.terminal_tipos_anadir(self.configuracion("terminal_tipos_por_defecto"), () => {
|
|
self.terminal_tipos_anadir(self.configuracion("terminal_tipos"), () => {
|
|
|
|
i18n_sobreescribir = self.configuracion(["i18n_sobreescribir", "sobreescribir"]);
|
|
idioma_por_defecto = self.configuracion(["idioma_por_defecto", "idioma"]);
|
|
idioma = self.configuracion(["idioma", "idioma_por_defecto"]);
|
|
|
|
self.i18n_anadir(self.configuracion("archivos_de_i18n_por_defecto"), null, () => {
|
|
self.i18n_anadir(self.configuracion("archivos_de_i18n"), null,() => {
|
|
|
|
terminar(true);
|
|
console.log("PASA");
|
|
|
|
});
|
|
});
|
|
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
return true;
|
|
};
|
|
|
|
this.nulos = nulos => typeof nulos != "boolean" ? self.configuracion("nulos", null, false, false) : nulos;
|
|
|
|
this.valor_por_defecto = (valor_por_defecto, nulos) => (
|
|
valor_por_defecto !== undefined && (self.nulos(nulos) || valor_por_defecto !== null) ? valor_por_defecto :
|
|
self.configuracion("valor_por_defecto", null, null, true)
|
|
);
|
|
|
|
this.coger_array_de_diccionarios = valor => valor && typeof valor == "object" ? valor instanceof Array ? valor : [valor] : [];
|
|
|
|
this.coger_array_de_strings = valor => (
|
|
valor && typeof valor == "object" && valor instanceof Array ? valor : [valor]
|
|
).filter(elemento => typeof elemento == "string" && elemento.trim()).map(elemento => elemento.trim());
|
|
|
|
this.configuracion = (claves, entradas, valor_por_defecto, nulos) => {
|
|
|
|
const m = (claves = self.coger_array_de_strings(claves)).length;
|
|
|
|
if(m){
|
|
|
|
const l = (entradas = [].concat(
|
|
self.coger_array_de_diccionarios(entradas),
|
|
[entradas, configuracion, configuracion_por_defecto]
|
|
)).length;
|
|
|
|
nulos = self.nulos(nulos);
|
|
|
|
for(let i = 0; i < l; i ++)
|
|
if(entradas[i] && typeof entradas[i] == "object")
|
|
for(let j = 0; j < m; j ++)
|
|
if(entradas[i][claves[j]] !== undefined && (nulos || entradas[i][claves[j]] !== null))
|
|
return entradas[i][claves[j]];
|
|
};
|
|
return self.valor_por_defecto(valor_por_defecto, nulos);
|
|
};
|
|
|
|
this.leer_archivo = (url, entradas) => {
|
|
|
|
let terminado = false;
|
|
const ajax = new XMLHttpRequest(),
|
|
callback = self.configuracion("callback",
|
|
typeof entradas == "function" ? (entradas = {callback : entradas}) :
|
|
entradas && typeof entradas == "object" ? entradas :
|
|
{}),
|
|
timeout = self.configuracion(["ajax_timeout", "timeout"], entradas),
|
|
terminar = codigo => (
|
|
!terminado &&
|
|
(terminado = true) &&
|
|
typeof callback == "function" &&
|
|
callback(ajax.responseText, ajax.status, ajax.readyState, codigo)
|
|
),
|
|
fecha = Date.now();
|
|
|
|
ajax.open("get", url, true);
|
|
ajax.timeout = timeout;
|
|
ajax.onreadystatechange = () => {
|
|
if(terminado)
|
|
return;
|
|
if(ajax.readyState == 4)
|
|
terminar(
|
|
(ajax.status >= 200 && ajax.status < 300) || [301, 302, 304].includes(ajax.status) ? "OK" :
|
|
"HTTP_ERROR");
|
|
else if(Date.now() - fecha > timeout)
|
|
terminar("TIMEOUT_FORZADO");
|
|
};
|
|
ajax.send(null);
|
|
|
|
ajax.onabort = () => terminar("ABORTADO");
|
|
ajax.onerror = () => terminar("ERROR");
|
|
ajax.ontimeout = () => terminar("TIMEOUT");
|
|
|
|
return ajax;
|
|
};
|
|
|
|
const configuracion_anadir = (entradas, sobreescribir, callback, i) => {
|
|
|
|
if(i >= entradas.length){
|
|
callback();
|
|
return;
|
|
};
|
|
|
|
const terminar = () => configuracion_anadir(entradas, sobreescribir, callback, i + 1);
|
|
|
|
if(!entradas[i]){
|
|
terminar();
|
|
return;
|
|
};
|
|
|
|
if(typeof entradas[i] == "object"){
|
|
if(entradas[i] instanceof Array)
|
|
configuracion_anadir(entradas[i], sobreescribir, terminar, 0);
|
|
else{
|
|
for(const clave in entradas[i])
|
|
if(sobreescribir || configuracion[clave] === undefined)
|
|
configuracion[clave] = entradas[i][clave];
|
|
terminar();
|
|
};
|
|
}else if(typeof entradas[i] == "string"){
|
|
if(!(entradas[i] = entradas[i].trim())){
|
|
terminar();
|
|
return;
|
|
};
|
|
|
|
let json;
|
|
|
|
if(entradas[i].match(/^(\{(.|[\r\n])+\}|\[(.|[\r\n])+\])$/)){
|
|
try{
|
|
json = JSON.parse(entradas[i]);
|
|
}catch(excepcion){};
|
|
if(json)
|
|
configuracion_anadir(json instanceof Array ? json : [json], sobreescribir, terminar, 0);
|
|
else
|
|
terminar();
|
|
}else
|
|
self.leer_archivo(entradas[i], salida => {
|
|
try{
|
|
json = JSON.parse(salida);
|
|
}catch(excepcion){};
|
|
if(json)
|
|
configuracion_anadir(json instanceof Array ? json : [json], sobreescribir, terminar, 0);
|
|
else
|
|
terminar();
|
|
});
|
|
}else
|
|
terminar();
|
|
|
|
};
|
|
|
|
this.configuracion_anadir = (entradas, sobreescribir, callback) => configuracion_anadir(
|
|
entradas && typeof entradas == "object" && entradas instanceof Array ? entradas : [entradas],
|
|
typeof sobreescribir == "boolean" ? sobreescribir : configuracion_sobreescribir,
|
|
callback,
|
|
0
|
|
);
|
|
|
|
this.string_variables = (string, variables, por_defecto) => {
|
|
|
|
const l = (variables = self.coger_array_de_diccionarios(variables)).length;
|
|
|
|
return (string || "" + string).replace(/\{([^\{\}]+)\}/g, (crudo, clave) => {
|
|
for(let i = 0; i < l; i ++)
|
|
if(variables[i][clave] !== undefined)
|
|
return variables[i][clave];
|
|
return por_defecto === undefined ? crudo : por_defecto;
|
|
});
|
|
};
|
|
|
|
const i18n = (claves, por_defecto) => {
|
|
|
|
const m = (claves = self.coger_array_de_strings(claves)).length,
|
|
idiomas = [idioma_por_defecto, idioma].concat(Object.keys(textos)),
|
|
l = idiomas.length;
|
|
|
|
for(let i = 0; i < l; i ++)
|
|
if(typeof idiomas[i] == "string" && textos[idiomas[i]])
|
|
for(let j = 0; j < m; j ++)
|
|
if(textos[idiomas[i]][claves[j]] !== undefined)
|
|
return textos[idiomas[i]][claves[j]];
|
|
return (
|
|
por_defecto !== undefined ? por_defecto :
|
|
m ? claves[0] :
|
|
self.configuracion("texto_por_defecto"));
|
|
};
|
|
|
|
this.i18n = (claves, variables, por_defecto) => self.string_variables(i18n(claves, por_defecto), variables);
|
|
|
|
const i18n_anadir = (entradas, sobreescribir, callback, i) => {
|
|
|
|
if(i >= entradas.length){
|
|
typeof callback == "function" && callback();
|
|
return;
|
|
};
|
|
|
|
const terminar = () => i18n_anadir(entradas, sobreescribir, callback, i + 1);
|
|
|
|
if(!entradas[i]){
|
|
terminar();
|
|
return;
|
|
};
|
|
|
|
if(typeof entradas[i] == "object"){
|
|
if(entradas[i] instanceof Array)
|
|
i18n_anadir(entradas[i], sobreescribir, terminar, 0);
|
|
else{
|
|
for(const lenguage in entradas[i]){
|
|
textos[lenguage] === undefined && (textos[lenguage] = {});
|
|
if(entradas[i][lenguage] && typeof entradas[i][lenguage] == "object")
|
|
for(const clave in entradas[i][lenguage])
|
|
if(sobreescribir || textos[lenguage][clave] === undefined)
|
|
textos[lenguage][clave] = entradas[i][lenguage][clave];
|
|
};
|
|
terminar();
|
|
};
|
|
}else if(typeof entradas[i] == "string"){
|
|
if(!(entradas[i] = entradas[i].trim())){
|
|
terminar();
|
|
return;
|
|
};
|
|
|
|
let json;
|
|
|
|
if(entradas[i].match(/^(\{(.|[\r\n])+\}|\[(.|[\r\n])+\])$/)){
|
|
try{
|
|
json = JSON.parse(entradas[i]);
|
|
}catch(excepcion){};
|
|
if(json)
|
|
i18n_anadir(json instanceof Array ? json : [json], sobreescribir, terminar, 0);
|
|
else
|
|
terminar();
|
|
}else
|
|
self.leer_archivo(entradas[i], salida => {
|
|
try{
|
|
json = JSON.parse(salida);
|
|
}catch(excepcion){};
|
|
if(json)
|
|
i18n_anadir(json instanceof Array ? json : [json], sobreescribir, terminar, 0);
|
|
else
|
|
terminar();
|
|
});
|
|
}else
|
|
terminar();
|
|
|
|
};
|
|
|
|
this.i18n_anadir = (entradas, sobreescribir, callback) => i18n_anadir(
|
|
entradas && typeof entradas == "object" && entradas instanceof Array ? entradas : [entradas],
|
|
typeof sobreescribir == "boolean" ? sobreescribir : i18n_sobreescribir,
|
|
callback,
|
|
0
|
|
);
|
|
|
|
const terminal_tipos_anadir = (entradas, callback, i, clave) => {
|
|
if(i > 10)
|
|
return;
|
|
|
|
if(!entradas || i >= entradas.length){
|
|
typeof callback == "function" && callback();
|
|
return;
|
|
};
|
|
|
|
const terminar = () => terminal_tipos_anadir(entradas, callback, i + 1, clave);
|
|
|
|
if(!entradas[i]){
|
|
terminar();
|
|
return;
|
|
};
|
|
|
|
if(typeof entradas[i] == "string"){
|
|
if(/^ *[a-z0-9]+ *$/i.test(entradas[i])){
|
|
if(clave === undefined && !terminal_tipos.some((tipos, j) => tipos.includes(entradas[i]) && !isNaN(clave = j))){
|
|
clave = terminal_tipos.length;
|
|
terminal_tipos.push([entradas[i]]);
|
|
}else
|
|
!terminal_tipos[clave].includes(entradas[i]) && terminal_tipos[clave].push(entradas[i]);
|
|
terminar();
|
|
return;
|
|
};
|
|
|
|
let json;
|
|
|
|
if(/^(\[(.|[\r\n])+\])$/.test(entradas[i])){
|
|
try{
|
|
json = JSON.parse(entradas[i]);
|
|
}catch(excepcion){};
|
|
if(json)
|
|
terminal_tipos_anadir(json, terminar, 0, clave);
|
|
else
|
|
terminar();
|
|
}else
|
|
self.leer_archivo(entradas[i], salida => {
|
|
try{
|
|
json = JSON.parse(salida);
|
|
}catch(excepcion){};
|
|
if(json)
|
|
terminal_tipos_anadir(json, terminar, 0, clave);
|
|
else
|
|
terminar();
|
|
});
|
|
}else if(typeof entradas[i] == "object" && entradas[i] instanceof Array)
|
|
terminal_tipos_anadir(entradas[i], terminar, 0);
|
|
else
|
|
terminar();
|
|
|
|
};
|
|
|
|
this.es_dispositivo_movil = () => modo_dispositivo == "movil" || (modo_dispositivo != "escritorio" && es_movil);
|
|
this.modo_gui_oscuro = () => modo_gui == "oscuro" || (modo_gui != "claro" && modo_gui_oscuro);
|
|
|
|
this.terminal_tipos_anadir = (entradas, callback) => terminal_tipos_anadir(entradas, callback, 0);
|
|
|
|
this.coger_id_tipo_terminal = tipo => {
|
|
|
|
const l = terminal_tipos.length;
|
|
|
|
if(typeof tipo == "string" && (tipo = tipo.trim().toLowerCase()))
|
|
for(let i = 0; i < l; i ++)
|
|
if(terminal_tipos[i].includes(tipo))
|
|
return i;
|
|
return 0;
|
|
};
|
|
|
|
this.coger_tipo_terminal = tipo => terminal_tipos[self.coger_id_tipo_terminal(tipo)][0].toUpperCase();
|
|
|
|
this.coger_traza = i => (new Error()).stack.replace(/^Error\s*?[\r\n]+/, "").trim().split(/[\r\n]+/).slice(1 + (i || 0)).map(linea => {
|
|
|
|
const matches = linea.match(re_bloque_de_traza);
|
|
|
|
return matches ? {
|
|
archivo : matches[4] || matches[9],
|
|
metodo : matches[3] || matches[8] || "",
|
|
linea : Number(matches[7] || matches[10])
|
|
} : null;
|
|
});
|
|
|
|
this.print = (tipo, mensaje, variables, i) => {
|
|
|
|
const fecha = new Date(),
|
|
conjunto = {
|
|
tipo_crudo : tipo,
|
|
tipo : self.coger_tipo_terminal(tipo),
|
|
i18n : mensaje,
|
|
...(typeof variables == "object" ? variables : {}),
|
|
...(self.coger_traza((isNaN(i) ? 1 : i) + 1) || {
|
|
linea : -1,
|
|
metodo : "UNKNOWN",
|
|
archivo : "UNKNOWN"
|
|
})
|
|
},
|
|
clave_tipo = conjunto.tipo.trim().toLowerCase();
|
|
let mensaje_procesado;
|
|
|
|
conjunto.line = conjunto.linea;
|
|
conjunto.method = conjunto.metodo;
|
|
conjunto.file = conjunto.archivo;
|
|
|
|
["year", "month", "date", "hours", "minutes", "seconds"].forEach(clave => {
|
|
|
|
let k = clave.substring(0, 1);
|
|
const valor = fecha["get" + (clave == "year" ? "FullYear" : k.toUpperCase() + clave.substring(1))]();
|
|
|
|
conjunto[clave == "date" ? "day" : clave] = valor;
|
|
conjunto[clave == "minutes" ? k = "i" : k] = valor;
|
|
conjunto[k + k] = ("00" + valor).slice(-2);
|
|
|
|
});
|
|
conjunto["yyyy"] = conjunto["year"];
|
|
|
|
conjunto.mensaje = self.i18n(mensaje, conjunto);
|
|
|
|
mensaje_procesado = self.string_variables(formato_terminal, conjunto);
|
|
|
|
console.log(conjunto);
|
|
|
|
switch(conjunto.tipo){
|
|
case " OK ":
|
|
console.log("%c" + mensaje_procesado, self.modo_gui_oscuro() ? terminal_ok_oscuro : terminal_ok_claro);
|
|
break;
|
|
case "INFO":
|
|
console.log("%c" + mensaje_procesado, self.modo_gui_oscuro() ? terminal_info_oscuro : terminal_info_claro);
|
|
break;
|
|
case "UNKN":
|
|
console.log("%c" + mensaje_procesado, self.modo_gui_oscuro() ? terminal_note_oscuro : terminal_note_claro);
|
|
break;
|
|
case "ERRO":
|
|
case "FAIL":
|
|
case "EXCE":
|
|
console.error(mensaje_procesado);
|
|
break;
|
|
case "WARN":
|
|
console.warn(mensaje_procesado);
|
|
break;
|
|
case "UNKN":
|
|
default:
|
|
console.log("%c" + mensaje_procesado, self.modo_gui_oscuro() ? terminal_unkn_oscuro : terminal_unkn_claro);
|
|
break;
|
|
};
|
|
|
|
};
|
|
|
|
constructor();
|
|
|
|
}; |