Claudio Francisco Orellana Andrades Senior Software Engineer

// Reglas puras: sin Vue, sin Pinia, sin red.export class FacturasService {  constructor(private readonly tope = 5_000_000) {}  saldo(f: Factura): number {    return Math.max(0, f.monto - f.abonado)  }  total(fs: Factura[]): number {    return fs.reduce((s, f) => s + this.saldo(f), 0)  }  excedeTope(fs: Factura[]): boolean {    return this.total(fs) > this.tope  }}export const facturasService = new FacturasService()

type Sobre<T> = T[] | { data?: T[] } // Rutas y formatos; el transporte es del cliente HTTP.export class RepositorioPedidos {  constructor(private readonly http: ClienteHttp) {}  async listar(cliente: string): Promise<PedidoCrudo[]> {    const r = await this.http.get<Sobre<PedidoCrudo>>(      '/pedidos', { cliente },    )    // Normaliza el sobre: siempre un arreglo.    return Array.isArray(r) ? r : (r.data ?? [])  }  cancelar(id: string): Promise<void> {    const ruta = '/pedidos/' + encodeURIComponent(id)    return this.http.delete(ruta)  }}

// Quien la usa recibe la interfaz, no la clase.export function crearAlmacenSeguro(): AlmacenSeguro {  return esNativo()    ? new AlmacenNativo()    : new AlmacenWebCifrado()} // La fábrica entra como parámetro, la real por defecto.export function useCobro(  crearPasarela: () => PasarelaPago = crearPasarelaReal,) {  const pasarela = crearPasarela()  const cobrar = (fs: Factura[]) => pasarela.cobrar(fs)  return { cobrar }}// En el test: useCobro(() => pasarelaFalsa)

// La credencial llega como getter: siempre la vigente.export function useCobrosPendientes(  token: () => string | null,) {  const facturas = ref<Factura[]>([])  const pendientes = computed(() =>    facturas.value.filter((f) => servicio.saldo(f) > 0),  )  async function cargar() {    const t = token()    facturas.value = t ? await repositorio.listar(t) : []  }  // Se compone: un refresco que se pausa en segundo plano.  useRefrescoPeriodico(cargar, { cadaMs: 120_000 })  return { facturas, pendientes, cargar }}

// Contrato propio: la app no conoce al proveedor.export interface PasarelaPago {  cobrar(facturas: Factura[]): Promise<string>}// Un adaptador por proveedor: traduce y valida.export const pasarelaA = (sdk: SdkA): PasarelaPago => ({  async cobrar(fs) {    const r = await sdk.crearCobro(aCobroA(fs))    return r.urlPago  },})// En los tests, una falsa: sin red ni cobros reales.export const pasarelaFalsa: PasarelaPago = {  cobrar: async () => '/pago/ok',}

// Envuelve la función sin cambiar su firma.export function compartirEnVuelo<T>(  pedir: (id: string) => Promise<T>,): (id: string) => Promise<T> {  const enVuelo = new Map<string, Promise<T>>()  return (id) => {    const previa = enVuelo.get(id)    // Dos lecturas iguales: una petición, objetos aparte.    if (previa) return previa.then(structuredClone)    const p = pedir(id).finally(() => enVuelo.delete(id))    enVuelo.set(id, p)    return p  }}

const pedidos = reactive(new Map<string, Pedido>()) // Cada mensaje trae un registro: se aplica en su lugar.canal.on('pedido', (nuevo: Pedido) => {  const actual = pedidos.get(nuevo.id)  // Nunca hacia atrás: uno viejo no pisa uno nuevo.  if (actual && nuevo.fecha <= actual.fecha) return  pedidos.set(nuevo.id, { ...actual, ...nuevo })})// El canal no tiene buzón: tras una ausencia larga, releo.watch(enPrimerPlano, (visible) => {  if (visible && ausenciaMs() >= 5 * 60_000) void releer()})

type EstadoPago = 'pendiente' | 'pagado' | 'fallido'type Insignia = { etiqueta: string; clase: string }// Si falta una variante, no compila.const ESTADOS: Readonly<Record<EstadoPago, Insignia>> = {  pendiente: { etiqueta: 'Pendiente', clase: 'bg-aviso' },  pagado: { etiqueta: 'Pagado', clase: 'bg-exito' },  fallido: { etiqueta: 'Fallido', clase: 'bg-alerta' },}// Un estado nuevo del backend no rompe la pantalla.export const insignia = (estado: string): Insignia =>  Object.hasOwn(ESTADOS, estado)    ? ESTADOS[estado as EstadoPago]    : { etiqueta: estado, clase: 'bg-neutro' }

// Cada bandera responde una sola pregunta.export function useCargaFacturas() {  const consultado = ref(false) // ¿ya pregunté?  const respondio = ref(false) // ¿contestó alguna vez?  const error = ref<string | null>(null)  const facturas = ref<Factura[]>([])   const cargandoInicial = computed(() => !consultado.value)  // «No tienes facturas» solo si el servidor lo confirmó.  const sinFacturas = computed(() =>    respondio.value && !error.value && !facturas.value.length,  )  // Un refresco fallido no borra lo que había: lo marca.  const desactualizada = computed(    () => respondio.value && error.value !== null,  )  return {    facturas,    cargandoInicial,    sinFacturas,    desactualizada,  }}

// Posiciones, no objetos: un índice por coincidencia.export function filtrar(textos: string[], q: string) {  const salida = new Int32Array(textos.length)  let n = 0  for (let i = 0; i < textos.length; i++) {    if (textos[i]?.includes(q)) salida[n++] = i  }  return salida.subarray(0, n)}// La vista materializa solo el tramo visible.export const visibles = computed(() => {  const { desde, hasta } = ventana.value  return [...posiciones.value.subarray(desde, hasta)]    .map((i) => filas[i])})