/**

 * @param { string | URL } urlDeServiceWorkerQueRecibeNotificaciones

 */

export async function activaNotificacionesPush(

 urlDeServiceWorkerQueRecibeNotificaciones) {

 // Valida que el navegador soporte notificaciones push.

 if (!('PushManager' in window))

  throw new Error("Este navegador no soporta notificaciones push.")

 // Valida que el navegador soporte notificaciones,

 if (!("Notification" in window))

  throw new Error("Este navegador no soporta notificaciones push.")

 // Valida que el navegador soporte service workers,

 if (!("serviceWorker" in navigator))

  throw new Error("Este navegador no soporta service workers.")

 // Recupera el permiso para usar notificaciones

 let permiso = Notification.permission

 if (permiso === "default") {

  // Permiso no asignado. Pide al usuario su autorización.

  permiso = await Notification.requestPermission()

 }

 // Valida que el usuario haya permitido usar notificaciones..

 if (permiso === "denied")

  throw new Error("Notificaciones bloqueadas.")

 const registro = await navigator.serviceWorker.register(

  urlDeServiceWorkerQueRecibeNotificaciones)

 console.log(urlDeServiceWorkerQueRecibeNotificaciones, "registrado.")

 console.log(registro)

 if (!("showNotification" in registro))

  throw new Error("Este navegador no soporta notificaciones.")

}

/**

 * Devuelve una literal de objeto que se puede usar para enviar

 * en formato JSON al servidor.

 * DTO es un acrónimo para Data Transder Object, u

 * objeto para transferencia de datos.

 * @param { PushSubscription } suscripcion

 */

export function calculaDtoParaSuscripcion(suscripcion) {

 const key = suscripcion.getKey("p256dh")

 const token = suscripcion.getKey("auth")

 const supported = PushManager.supportedContentEncodings

 const encodings = Array.isArray(supported) && supported.length > 0

  ? supported

  : ["aesgcm"]

 const endpoint = suscripcion.endpoint

 const publicKey = key === null

  ? null

  : btoa(String.fromCharCode.apply(null, new Uint8Array(key)))

 const authToken = token === null

  ? null

  : btoa(String.fromCharCode.apply(null, new Uint8Array(token)))

 const contentEncoding = encodings[0]

 return {

  endpoint,

  publicKey,

  authToken,

  contentEncoding

 }

}

import { getSuscripcionPush } from "./getSuscripcionPush.js"

export async function cancelaSuscripcionPush() {

 const suscripcion = await getSuscripcionPush()

 const resultado = suscripcion === null

  ? false

  : await suscripcion.unsubscribe()

 return resultado === true ? suscripcion : null

}

import { ProblemDetailsError } from "./ProblemDetailsError.js"

/**

 * Espera a que la promesa de un fetch termine. Si

 * hay error, lanza una excepción.

 * 

 * @param {Promise<Response> } servicio

 */

export async function consume(servicio) {

 const respuesta = await servicio

 if (respuesta.ok) {

  return respuesta

 } else {

  const contentType = respuesta.headers.get("Content-Type")

  if (contentType === "application/problem+json; charset=utf-8")

   throw new ProblemDetailsError(await respuesta.json())

  else

   throw new Error(respuesta.statusText)

 }

}

import { consume } from "./consume.js"

import { muestraObjeto } from "./muestraObjeto.js"

import { recibeJson } from "./recibeJson.js"

/**

 * @param {string} url

 * @param { "GET" | "POST"| "PUT" | "PATCH" | "DELETE" | "TRACE" | "OPTIONS"

 *  | "CONNECT" | "HEAD" } metodoHttp

 */

export async function descargaVista(url, metodoHttp = "GET") {

 const respuesta = await consume(recibeJson(url, metodoHttp))

 const json = await respuesta.json()

 muestraObjeto(document, json)

 return json

}

/**

 * @param { string } url

 * @param { Object } body

 * @param { "GET" | "POST"| "PUT" | "PATCH" | "DELETE" | "TRACE" | "OPTIONS"

 *  | "CONNECT" | "HEAD" } metodoHttp

 */

export async function enviaJsonRecibeJson(url, body, metodoHttp = "POST") {

 return fetch(

  url,

  {

   method: metodoHttp,

   headers: {

    "Content-Type": "application/json",

    "Accept": "application/json, application/problem+json"

   },

   body: JSON.stringify(body)

  }

 )

}

export async function getSuscripcionPush() {

 // Recupera el service worker registrado.

 const registro = await navigator.serviceWorker.ready

 return registro.pushManager.getSubscription()

}

import { muestraError } from "./muestraError.js"

/**

 * Intercepta Response.prototype.json para capturar errores de parseo

 * y asegurar que se reporten correctamente en navegadores Chromium.

 */

{

 const originalJson = Response.prototype.json

 Response.prototype.json = function () {

  // Llamamos al método original usando el contexto (this) de la respuesta

  return originalJson.apply(this, arguments)

   .catch((/** @type {any} */ error) => {

    // Corrige un error de Chrome que evita el manejo correcto de errores.

    throw new Error(error)

   })

 }

}

window.onerror = function (

  /** @type {string} */ _message,

  /** @type {string} */ _url,

  /** @type {number} */ _line,

  /** @type {number} */ _column,

  /** @type {Error} */ errorObject

) {

 muestraError(errorObject)

 return true

}

window.addEventListener('unhandledrejection', event => {

 muestraError(event.reason)

 event.preventDefault()

})

import { ProblemDetailsError } from "./ProblemDetailsError.js"

/**

 * Muestra los datos de una Error en la consola y en un cuadro de alerta.

 * @param { ProblemDetailsError | Error | null } error descripción del error.

 */

export function muestraError(error) {

 if (error === null) {

  console.error("Error")

  alert("Error")

 } else if (error instanceof ProblemDetailsError) {

  const problemDetails = error.problemDetails

  let mensaje =

   typeof problemDetails["title"] === "string" ? problemDetails["title"] : ""

  if (typeof problemDetails["detail"] === "string") {

   if (mensaje !== "") {

    mensaje += "\n\n"

   }

   mensaje += problemDetails["detail"]

  }

  if (mensaje === "") {

   mensaje = "Error"

  }

  console.error(error, problemDetails)

  alert(mensaje)

 } else {

  console.error(error)

  alert(error.message)

 }

}

/**

 * @param {Document | HTMLElement | ShadowRoot} raizHtml

 * @param { any } objeto

 */

export function muestraObjeto(raizHtml, objeto) {

 for (const [nombre, definiciones] of Object.entries(objeto)) {

  if (Array.isArray(definiciones)) {

   muestraArray(raizHtml, nombre, definiciones)

  } else if (definiciones !== undefined && definiciones !== null) {

   muestraElemento(raizHtml, nombre, definiciones)

  }

 }

}

/**

 * @param { string } nombre

 */

export function selectorDeNombre(nombre) {

 return `[id="${nombre}"],[name="${nombre}"],[data-name="${nombre}"]`

}

/**

 * @param { Document | HTMLElement | ShadowRoot } raizHtml

 * @param { string } propiedad

 * @param {any[]} valores

 */

function muestraArray(raizHtml, propiedad, valores) {

 const conjunto = new Set(valores)

 const elementos = raizHtml.querySelectorAll(selectorDeNombre(propiedad))

 if (elementos.length === 1 && elementos[0] instanceof HTMLSelectElement) {

  muestraOptions(elementos[0], conjunto)

 } else {

  muestraInputs(elementos, conjunto)

 }

}

/**

 * @param {HTMLSelectElement} select

 * @param {Set<any>} conjunto

 */

function muestraOptions(select, conjunto) {

 for (let i = 0, options = select.options, len = options.length; i < len; i++) {

  const option = options[i]

  option.selected = conjunto.has(option.value)

 }

}

/**

 * @param {NodeListOf<Element>} elementos

 * @param {Set<any>} conjunto

 */

function muestraInputs(elementos, conjunto) {

 for (let i = 0, len = elementos.length; i < len; i++) {

  const elemento = elementos[i]

  if (elemento instanceof HTMLInputElement) {

   elemento.checked = conjunto.has(elemento.value)

  }

 }

}

const data_ = "data-"

const data_Length = data_.length

/**

 * @param {Document | HTMLElement | ShadowRoot} raizHtml

 * @param {string} nombre

 * @param {{ [s: string]: any; } } definiciones

 */

function muestraElemento(raizHtml, nombre, definiciones) {

 const elemento = raizHtml.querySelector(selectorDeNombre(nombre))

 if (elemento !== null) {

  for (const [propiedad, valor] of Object.entries(definiciones)) {

   if (propiedad in elemento) {

    elemento[propiedad] = valor

   } else if (

    propiedad.length > data_Length

    && propiedad.startsWith(data_)

    && elemento instanceof HTMLElement

   ) {

    elemento.dataset[propiedad.substring(data_Length)] = valor

   }

  }

 }

}

export class ProblemDetailsError extends Error {

 /**

  * Detalle de los errores devueltos por un servicio.

  * Crea una instancia de ProblemDetailsError.

  * @param {object} problemDetails Objeto con la descripcipon del error.

  */

 constructor(problemDetails) {

  super(typeof problemDetails["detail"] === "string"

   ? problemDetails["detail"]

   : (typeof problemDetails["title"] === "string"

    ? problemDetails["title"]

    : "Error"))

  this.problemDetails = problemDetails

 }

}

/**

 * @param {string} url

 * @param { "GET" | "POST"| "PUT" | "PATCH" | "DELETE" | "TRACE" | "OPTIONS"

 *  | "CONNECT" | "HEAD" } metodoHttp

 */

export async function recibeJson(url, metodoHttp = "GET") {

 return fetch(

  url,

  {

   method: metodoHttp,

   headers: { "Accept": "application/json, application/problem+json" }

  }

 )

}

/**

 * @param { ArrayBuffer } applicationServerKey

 */

export async function suscribeAPush(applicationServerKey) {

 // Recupera el service worker registrado.

 const registro = await navigator.serviceWorker.ready

 return registro.pushManager.subscribe({

  userVisibleOnly: true,

  applicationServerKey

 })

}

/**

 * @param { string } base64String

 */

export function urlBase64ToUint8Array(base64String) {

 const padding = "=".repeat((4 - (base64String.length % 4)) % 4)

 const base64 = (base64String + padding).replace(/\-/g, '+').replace(/_/g, '/')

 const rawData = atob(base64)

 const outputArray = new Uint8Array(rawData.length)

 for (let i = 0; i < rawData.length; ++i) {

  outputArray[i] = rawData.charCodeAt(i)

 }

 return outputArray

}