/**
* @archivo create-logger.js
* @módulo crear registrador
* /
importar ventana desde 'global/window';
// Esta es la variable de seguimiento privada para el historial de registro.
let historia = [];
/ **
* Registrar mensajes en la consola e historial según el tipo de mensaje
*
* @privado
* @param {cadena} tipo
* El nombre del método de consola a usar.
*
* @param {Array} argumentos
* Los argumentos que se pasarán al método de consola coincidente.
* /
const LogByTypeFactory = (nombre, registro) => (tipo, nivel, argumentos) => {
const lvl = log.niveles[nivel];
const lvlRegExp = new RegExp(`^(${lvl})$`);
if (escriba !== 'registro') {
// Agregue el tipo al frente del mensaje cuando no sea "registro".
args.unshift(type.toUpperCase() + ':');
}
// Agregar prefijo de consola después de agregar al historial.
argumentos.unshift(nombre + ':');
// Agregue un clon de los argumentos en este punto al historial.
si (historia) {
historia.push([].concat(args));
// solo almacena 1000 entradas de historial
const empalme = historia.longitud - 1000;
historia.empalme(0, empalme > 0? empalme: 0);
}
// Si no hay una consola, no intente enviar mensajes, pero lo harán
// aún se almacenará en el historial.
if (!ventana.consola) {
devolver;
}
// Los estaba configurando una vez fuera de esta función, pero conteniéndolos
// en la función hace que sea más fácil probar casos donde la consola no existe
// cuando se ejecuta el módulo.
let fn = ventana.consola[tipo];
si (!fn && escriba === 'depurar') {
// Ciertos navegadores no tienen soporte para console.debug. Para esos, nosotros
// debe tener como valor predeterminado el registro comparable más cercano.
fn = ventana.consola.info || ventana.consola.log;
}
// Rescatar si no hay consola o si este tipo no está permitido por el
// nivel de registro actual.
if (!fn || !lvl || !lvlRegExp.test(tipo)) {
devolver;
}
fn[Array.isArray(argumentos) ? 'aplicar' : 'llamar'](window.console, args);
};
Exportar función predeterminada createLogger(nombre) {
// Esta es la variable de seguimiento privada para el nivel de registro.
let nivel = 'info';
// el logByType curry vinculado al registro e historial específicos
let logByType;
/ **
* Registra mensajes de depuración simples. Similar a `console.log`.
*
* Debido a [limitaciones](https://github.com/jsdoc3/jsdoc/issues/955#issuecomment-313829149)
* de nuestra plantilla JSDoc, no podemos documentar correctamente esto como una función
* y un espacio de nombres, por lo que la firma de su función se documenta aquí.
*
* #### Argumentos
* ##### *argumentos
* Mezclado[]
*
* Cualquier combinación de valores que se pueda pasar a `console.log()`.
*
* #### Valor devuelto
*
* `indefinido`
*
* @espacio de nombres
* @param {Argumentos mixtos[]}
* Uno o más mensajes u objetos que deben registrarse.
* /
const registro = función (... argumentos) {
logByType('registro', nivel, argumentos);
};
// Este es el ayudante logByType que usan los métodos de registro a continuación
logByType = LogByTypeFactory(nombre, registro);
/ **
* Cree un nuevo subregistrador que encadene el nombre antiguo con el nuevo nombre.
*
* Por ejemplo, hacer `videojs.log.createLogger('player')` y luego usar ese registrador registrará lo siguiente:
* ```js
* mylogger('foo');
* // > VIDEOJS: reproductor: foo
* ```
*
* @param {cadena} nombre
* El nombre para agregar llamar al nuevo registrador
* @return {Objeto}
* /
log.createLogger = (subnombre) => createLogger(nombre + ': ' + subnombre);
/ **
* Enumeración de los niveles de registro disponibles, donde las claves son los nombres de los niveles
* y los valores son cadenas separadas por `|` que contienen métodos de registro permitidos
* en ese nivel de registro. Estas cadenas se utilizan para crear una expresión regular
* coincide con el nombre de la función que se llama.
*
* Los niveles proporcionados por Video.js son:
*
* - `apagado`: No coincide con llamadas. Cualquier valor que pueda convertirse en `falso` tendrá
* este efecto. El más restrictivo.
* - `todos`: Coincide solo con las funciones proporcionadas por Video.js (`debug`, `log`,
* `log.warn` y `log.error`).
* - `depuración`: Coincide con las llamadas `log.debug`, `log`, `log.warn` y `log.error`.
* - `info` (predeterminado): Coincide con las llamadas `log`, `log.warn` y `log.error`.
* - `avisar`: Coincide con las llamadas `log.warn` y `log.error`.
* - `error`: Coincide solo con las llamadas `log.error`.
*
* @type {Objeto}
* /
registro.niveles = {
todo: 'depuración|registro|aviso|error',
apagado: '',
depuración: 'depuración|registro|aviso|error',
información: 'registro|aviso|error',
advertir: 'advertir|error',
error: 'error',
Nivel predeterminado
};
/ **
* Obtener o establecer el nivel de registro actual.
*
* Si se proporciona una cadena que coincide con una clave de {@link module:log.levels}, actúa
* como colocador.
*
* @param {cadena} [nivel]
* Pase un nivel válido para establecer un nuevo nivel de registro.
*
* @return {cadena}
* El nivel de registro actual.
* /
registro.nivel = (lvl) => {
if (tipo de nivel === 'cadena') {
if (!log.levels.hasOwnProperty(lvl)) {
lanzar un nuevo error(`"${lvl}" en un nivel de registro no válido`);
}
nivel = lvl;
}
nivel de retorno;
};
/ **
* Devuelve una matriz que contiene todo lo que se ha registrado en el historial.
*
* Esta matriz es un clon superficial del registro de historial interno. Sin embargo, su
* los contenidos _no_ están clonados; entonces, la mutación de objetos dentro de esta matriz
* mutarlos en la historia.
*
* @return {Array}
* /
registro.historia = () => historia ? [].concat(historia) : [];
/ **
* Le permite filtrar el historial por el nombre del registrador dado
*
* @param {cadena} fnombre
* El nombre a filtrar por
*
* @return {Array}
* La lista filtrada para volver
* /
log.history.filter = (fname) => {
return (historial || []).filter((elementohistorial) => {
// si el primer ítem en cada historyItem incluye `fname`, entonces es una coincidencia
devuelve nueva RegExp(`.*${fname}.*`).test(historyItem[0]);
});
};
/ **
* Borra el seguimiento del historial interno, pero no evita más historial
* seguimiento.
* /
log.history.clear = () => {
si (historia) {
historia.longitud = 0;
}
};
/ **
* Deshabilite el seguimiento del historial si está habilitado actualmente.
* /
log.history.disable = () => {
si (historia! == nulo) {
historia.longitud = 0;
historia = nulo;
}
};
/ **
* Habilite el seguimiento del historial si actualmente está deshabilitado.
* /
log.history.habilitar = () => {
si (historial === nulo) {
historia = [];
}
};
/ **
* Registros de mensajes de error. Similar a `console.error`.
*
* @param {Argumentos mixtos[]}
* Uno o más mensajes u objetos que deben registrarse como un error
* /
log.error = (... argumentos) => logByType('error', nivel, argumentos);
/ **
* Registros de mensajes de advertencia. Similar a `console.warn`.
*
* @param {Argumentos mixtos[]}
* Uno o más mensajes u objetos que deben registrarse como advertencia.
* /
registro.advertencia = (... argumentos) => logByType('advertir', nivel, argumentos);
/ **
* Registros de mensajes de depuración. Similar a `console.debug`, pero también puede actuar como un comparable
* registro si `console.debug` no está disponible
*
* @param {Argumentos mixtos[]}
* Uno o más mensajes u objetos que deben registrarse como depuración.
* /
log.debug = (... argumentos) => logByType('depuración', nivel, argumentos);
registro de retorno;
}