Bloque 8: POO, patrones y proyecto final

// bank-account.js
export class CuentaBancaria {
  #saldo;

  constructor(saldoInicial = 0) {
    if (saldoInicial < 0) throw new Error("Saldo inicial no válido");
    this.#saldo = saldoInicial;
  }

  get saldo() { return this.#saldo; }

  ingresar(cantidad) {
    if (cantidad <= 0) throw new Error("Cantidad no válida");
    this.#saldo += cantidad;
  }

  retirar(cantidad) {
    if (cantidad <= 0) throw new Error("Cantidad no válida");
    if (cantidad > this.#saldo) throw new Error("Fondos insuficientes");
    this.#saldo -= cantidad;
  }
}

// bank-account.test.js
import { CuentaBancaria } from "./bank-account.js";

test("saldo inicial", () => {
  expect(new CuentaBancaria(100).saldo).toBe(100);
});

test("ingresar incrementa saldo", () => {
  const c = new CuentaBancaria(100);
  c.ingresar(50);
  expect(c.saldo).toBe(150);
});

test("ingresar cantidad negativa lanza error", () => {
  expect(() => new CuentaBancaria(0).ingresar(-5)).toThrow("Cantidad no válida");
});

test("retirar sin fondos lanza error", () => {
  const c = new CuentaBancaria(100);
  expect(() => c.retirar(200)).toThrow("Fondos insuficientes");
});

test("retirar descuenta del saldo", () => {
  const c = new CuentaBancaria(200);
  c.retirar(70);
  expect(c.saldo).toBe(130);
});

class Vehiculo {
  #encendido = false;

  constructor(marca, color) {
    this.marca = marca;
    this.color = color;
  }

  get estaEncendido() { return this.#encendido; }
  encender() { this.#encendido = true; }
  apagar()  { this.#encendido = false; }

  descripcion() {
    return `${this.marca} ${this.color} — ${this.estaEncendido ? "encendido" : "apagado"}`;
  }
}

class Coche extends Vehiculo {
  constructor(marca, color, puertas) {
    super(marca, color);
    this.puertas = puertas;
  }

  descripcion() {
    return `${super.descripcion()} · ${this.puertas} puertas`;
  }
}

class Moto extends Vehiculo {
  constructor(marca, color, cc) {
    super(marca, color);
    this.cc = cc;
  }

  descripcion() {
    return `${super.descripcion()} · ${this.cc} cc`;
  }
}

// Polimorfismo
const flota = [
  new Coche("Seat", "rojo", 5),
  new Moto("Honda", "negra", 600),
  new Coche("Tesla", "blanco", 4),
];

flota.forEach(v => {
  v.encender();
  console.log(v.descripcion());
});

export class Stack {
  #items = [];

  push(item) { this.#items.push(item); }

  pop() {
    if (this.isEmpty()) throw new Error("Stack vacío");
    return this.#items.pop();
  }

  peek() {
    if (this.isEmpty()) throw new Error("Stack vacío");
    return this.#items[this.#items.length - 1];
  }

  isEmpty() { return this.#items.length === 0; }

  get size() { return this.#items.length; }
}

// test
const s = new Stack();
s.push(10);
s.push(20);
expect(s.peek()).toBe(20);
expect(s.pop()).toBe(20);
expect(s.size).toBe(1);
expect(s.isEmpty()).toBe(false);

export class EventBus {
  #listeners = {};

  on(evento, fn) {
    (this.#listeners[evento] ??= []).push(fn);
  }

  off(evento, fn) {
    this.#listeners[evento] =
      this.#listeners[evento]?.filter(f => f !== fn) ?? [];
  }

  emit(evento, datos) {
    this.#listeners[evento]?.forEach(fn => fn(datos));
  }
}

// tests
const bus = new EventBus();
let recibido = null;
const handler = (d) => { recibido = d; };

bus.on("test", handler);
bus.emit("test", 42);
expect(recibido).toBe(42);

bus.off("test", handler);
bus.emit("test", 99);
expect(recibido).toBe(42);  // no cambió: handler eliminado

export function crearProducto(tipo, nombre, precio, extras = {}) {
  if (!["digital", "fisico"].includes(tipo))
    throw new Error(`Tipo "${tipo}" no soportado`);

  const producto = {
    tipo,
    nombre,
    precio,
    ...extras,

    aplicarDescuento(pct) {
      this.precio = +(this.precio * (1 - pct / 100)).toFixed(2);
    },

    info() {
      let base = `${this.nombre}: ${this.precio.toFixed(2)} € (${this.tipo})`;
      if (this.tipo === "digital") base += " [descargable]";
      if (this.tipo === "fisico") base += ` [${this.peso} kg]`;
      return base;
    },
  };

  if (tipo === "fisico" && extras.peso == null)
    throw new Error("Peso obligatorio para productos físicos");

  return producto;
}

// test
const e = crearProducto("digital", "Ebook", 9.99);
expect(e.descargable).toBe(true);
e.aplicarDescuento(20);
expect(e.precio).toBe(7.99);

const f = crearProducto("fisico", "Libro", 19.99, { peso: 0.4 });
expect(f.peso).toBe(0.4);

import { EventBus } from "./event-bus.js";

export class Carrito {
  #items = [];
  #bus = new EventBus();

  on(evento, fn) { this.#bus.on(evento, fn); }
  off(evento, fn) { this.#bus.off(evento, fn); }

  agregar(producto) {
    this.#items.push(producto);
    this.#bus.emit("añadido", producto);
  }

  eliminar(nombre) {
    const idx = this.#items.findIndex(p => p.nombre === nombre);
    if (idx === -1) return null;
    const [elim] = this.#items.splice(idx, 1);
    this.#bus.emit("eliminado", elim);
    return elim;
  }

  vaciar() { this.#items = []; }

  get total() {
    return +this.#items.reduce((s, p) => s + p.precio, 0).toFixed(2);
  }

  get items() { return [...this.#items]; }
}

// test
const carrito = new Carrito();
let avisos = 0;
carrito.on("añadido", () => avisos++);

carrito.agregar({ nombre: "Camiseta", precio: 20 });
carrito.agregar({ nombre: "Gorra", precio: 15 });
expect(avisos).toBe(2);
expect(carrito.total).toBe(35);

carrito.eliminar("Camiseta");
expect(carrito.total).toBe(15);
expect(carrito.items.length).toBe(1);

export function aplanar(arr) {
  const resultado = [];
  for (const item of arr) {
    if (Array.isArray(item)) {
      resultado.push(...aplanar(item));
    } else {
      resultado.push(item);
    }
  }
  return resultado;
}

// tests
test("aplanar arrays anidados", () => {
  expect(aplanar([1, [2, [3, [4]]]])).toEqual([1, 2, 3, 4]);
});

test("array vacío", () => {
  expect(aplanar([])).toEqual([]);
});

test("array ya plano", () => {
  expect(aplanar([1, 2, 3])).toEqual([1, 2, 3]);
});

export function debounce(fn, delay) {
  let timerId = null;

  return function (...args) {
    clearTimeout(timerId);
    timerId = setTimeout(() => fn.apply(this, args), delay);
  };
}

// test (usando fake timers de Jest)
beforeEach(() => jest.useFakeTimers());
afterEach(() => jest.useRealTimers());

test("no ejecuta hasta que pasa el delay", () => {
  const fn = jest.fn();
  const debounced = debounce(fn, 300);

  debounced();
  debounced();
  debounced();

  expect(fn).not.toHaveBeenCalled();

  jest.advanceTimersByTime(300);
  expect(fn).toHaveBeenCalledTimes(1);
});

export function deepClone(obj) {
  if (obj === null || typeof obj !== "object") return obj;
  if (Array.isArray(obj)) return obj.map(item => deepClone(item));

  const clon = {};
  for (const key of Object.keys(obj)) {
    clon[key] = deepClone(obj[key]);
  }
  return clon;
}

// tests
test("clon profundo de objetos anidados", () => {
  const original = { a: { b: { c: 42 } }, d: [1, [2, 3]] };
  const clon = deepClone(original);

  expect(clon).toEqual(original);
  expect(clon).not.toBe(original);
  expect(clon.a).not.toBe(original.a);
  expect(clon.a.b).not.toBe(original.a.b);
  expect(clon.d).not.toBe(original.d);
});

test("primitivos se devuelven tal cual", () => {
  expect(deepClone(42)).toBe(42);
  expect(deepClone("hola")).toBe("hola");
  expect(deepClone(null)).toBe(null);
});