'use strict';

const tasca = new Tasca({
  id: 6, titol: 'Pressupost de la fusteria', responsable: 'Iván',
  prioritat: 'alta', horesEstimades: 5, dataLimit: '2026-09-05'
});

// ✗ 1 · Se salta la R6: de 'pendent' a 'feta' sense passar per 'en-curs'
tasca.estat = 'feta';

// ✗ 2 · Se salta la R3: hores fora del rang 1-40
tasca.horesEstimades = 500;

// ✗ 3 · Estat inexistent: ni tan sols és a Tasca.ESTATS
tasca.estat = 'arxivada';

// ✗ 4 · Se salta la R8: cadena buida en lloc de null
tasca.responsable = '';

console.log(tasca.descripcio('2026-09-20'));
// ? [6] Pressupost de la fusteria ·  · 500 h

'use strict';

class Tasca {
  constructor(dades) {
    this.id = dades.id;
    this.titol = dades.titol;
    this.estat = dades.estat ?? 'pendent';
    this.horesEstimades = dades.horesEstimades;
    this.dataLimit = dades.dataLimit;
  }

  get oberta() {
    return this.estat !== 'feta';
  }

  get diesRestants() {
    const limit = new Date(this.dataLimit);
    const avui = new Date('2026-09-20');
    return Math.round((limit - avui) / (1000 * 60 * 60 * 24));
  }
}

const fusteria = new Tasca({ id: 6, titol: 'Pressupost de la fusteria', horesEstimades: 5, dataLimit: '2026-09-05' });

console.log(fusteria.oberta);          // true    ← sense parèntesis
console.log(fusteria.diesRestants);    // -15     ← vençuda fa 15 dies

// ✗ Dada derivada guardada: cal recordar-se d'actualitzar-la SEMPRE
this.oberta = dades.estat !== 'feta';
tasca.estat = 'feta';
console.log(tasca.oberta);         // true  ← mentida

const equip = {
  membres: ['Marta', 'Iván', 'Lucía'],
  get mida() { return this.membres.length; }
};
console.log(equip.mida);           // 3

class Tauler {
  constructor(nom, tasques = []) {
    this.nom = nom;
    this.tasques = [...tasques];
  }

  get total()          { return this.tasques.length; }
  get obertes()        { return this.tasques.filter((t) => t.oberta); }
  get horesTotals()    { return this.tasques.reduce((s, t) => s + t.horesEstimades, 0); }
  get horesObertes()   { return this.obertes.reduce((s, t) => s + t.horesEstimades, 0); }
  get esforc()         { return this.tasques.reduce((s, t) => s + t.esforc(), 0); }
}

console.log(tauler.total);           // 6
console.log(tauler.horesTotals);     // 48
console.log(tauler.horesObertes);    // 45
console.log(tauler.esforc);          // 124

'use strict';

class Tasca {
  constructor(dades) {
    this.id = dades.id;
    this._hores = 0;
    this.horesEstimades = dades.horesEstimades;   // ← passa pel setter, es valida
  }

  get horesEstimades() {
    return this._hores;
  }

  set horesEstimades(valor) {
    if (typeof valor !== 'number' || Number.isNaN(valor)) {
      throw new ErrorDeValidacio('Les hores han de ser un nombre.', 'horesEstimades', valor);
    }
    if (valor <= 0 || valor > 40) {                                              // R3
      throw new ErrorDeValidacio('Les hores han de ser entre 1 i 40.', 'horesEstimades', valor);
    }
    this._hores = valor;
  }
}

const t = new Tasca({ id: 6, horesEstimades: 5 });
console.log(t.horesEstimades);      // 5

t.horesEstimades = 8;               // ✓ vàlid
console.log(t.horesEstimades);      // 8

try {
  t.horesEstimades = 500;           // ✗ ara SÍ que salta
} catch (error) {
  console.error(error.message);     // 'Les hores han de ser entre 1 i 40.'
}
console.log(t.horesEstimades);      // 8   ← l'objecte ha quedat intacte

class NomesLectura {
  #valor = 42;
  get valor() { return this.#valor; }
}

const nl = new NomesLectura();
// nl.valor = 7;      // ✗ TypeError: Cannot set property valor… which has only a getter

class Tasca {
  get oberta()         { … }          // ✓ dada pròpia, barata, sense arguments
  get diesRestants()   { … }          // ✓ derivat de dataLimit

  estaVencuda(avui)    { … }          // ✓ mètode: rep un argument
  canviarEstat(nou)    { … }          // ✓ mètode: és una ACCIÓ, i pot llançar
  esforc()             { … }          // ✓ mètode: podria ser getter; es manté per coherència
}

// Si horesObertes fos costós, això seria un desastre invisible
for (const tasca of tauler.tasques) {
  console.log(tasca.horesEstimades / tauler.horesObertes);   // ← recalcula a cada volta
}

'use strict';

class Tasca {
  #estat = 'pendent';             // camp privat, amb valor inicial (R5)

  constructor(dades) {
    this.id = dades.id;
    this.titol = dades.titol;
    if (dades.estat !== undefined) this.#validarIAssignarEstat(dades.estat, true);
  }

  get estat() {
    return this.#estat;           // lectura pública, escriptura impossible
  }

  canviarEstat(nou) {
    this.#validarIAssignarEstat(nou, false);
    return this;
  }

  #validarIAssignarEstat(nou, esInicial) { /* apartat 6 */ }
}

const t = new Tasca({ id: 6, titol: 'Pressupost de la fusteria' });

console.log(t.estat);             // 'pendent'   ← es llegeix pel getter
// t.#estat;                      // ✗ SyntaxError: Private field '#estat' must be declared in an enclosing class
// t.estat = 'feta';              // ✗ TypeError: només té getter

const tasca = new Tasca({ id: 6, titol: 'Pressupost de la fusteria' });

tasca.estat = 'feta';                       // en mode estricte → TypeError
console.log(tasca.estat);                   // 'pendent'  ← intacta

tasca.canviarEstat('en-curs');              // ✓ únic camí
console.log(tasca.estat);                   // 'en-curs'

'use strict';

class Tasca {
  // ── Configuració privada de la classe ───────────────────────────
  static #TRANSICIONS = {                        // R6
    pendent: ['en-curs'],
    'en-curs': ['pendent', 'feta'],
    feta: []
  };
  static #MARQUES = { pendent: '○', 'en-curs': '▸', feta: '✓' };
  static #PESOS = { alta: 3, mitjana: 2, baixa: 1 };
  static #ultimId = 6;                           // R1: el backlog arriba fins al 6

  // ── Estat privat de la instància ────────────────────────────────
  #estat = 'pendent';                            // R5
  #hores;
  #etiquetes = [];

  constructor(dades) {
    this.id = dades.id ?? Tasca.seguentId();
    this.titol = Tasca.#validarTitol(dades.titol);
    this.responsable = dades.responsable || null;                 // R8
    this.prioritat = dades.prioritat ?? 'mitjana';
    this.dataLimit = dades.dataLimit;
    this.revisor = dades.revisor ?? null;

    this.horesEstimades = dades.horesEstimades;                   // passa pel setter (R3)
    this.etiquetes = dades.etiquetes ?? [];                       // passa pel setter (R9)
    if (dades.estat !== undefined) this.#assignarEstatInicial(dades.estat);
  }

  // ── Estàtics ────────────────────────────────────────────────────
  static seguentId() {
    Tasca.#ultimId += 1;
    return Tasca.#ultimId;
  }

  static #validarTitol(titol) {                                   // mètode estàtic PRIVAT
    if (typeof titol !== 'string' || titol.trim() === '') {
      throw new ErrorDeValidacio('El títol no pot estar buit.', 'titol', titol);   // R2
    }
    return titol.trim();
  }

  // ── Getters ─────────────────────────────────────────────────────
  get estat()          { return this.#estat; }
  get horesEstimades() { return this.#hores; }
  get etiquetes()      { return [...this.#etiquetes]; }           // còpia defensiva
  get oberta()         { return this.#estat !== 'feta'; }
  get esforc()         { return (Tasca.#PESOS[this.prioritat] ?? 0) * this.#hores; }
  get marca()          { return Tasca.#MARQUES[this.#estat]; }

  // ── Setters ─────────────────────────────────────────────────────
  set horesEstimades(valor) {
    if (typeof valor !== 'number' || !(valor > 0 && valor <= 40)) {
      throw new ErrorDeValidacio('Les hores han de ser un nombre entre 1 i 40.', 'horesEstimades', valor);
    }
    this.#hores = valor;
  }

  set etiquetes(llista) {
    if (!Array.isArray(llista)) {
      throw new ErrorDeValidacio('Les etiquetes han de ser un array.', 'etiquetes', llista);
    }
    this.#etiquetes = [...new Set(llista.map((e) => String(e).trim().toLowerCase()))].filter(Boolean);   // R9
  }

  // ── Mètodes privats ─────────────────────────────────────────────
  #assignarEstatInicial(estat) {
    if (!Object.hasOwn(Tasca.#TRANSICIONS, estat)) {
      throw new ErrorDeValidacio(`Estat desconegut: "${estat}".`, 'estat', estat);
    }
    this.#estat = estat;
  }

  #potAnarA(nou) {
    return (Tasca.#TRANSICIONS[this.#estat] ?? []).includes(nou);
  }

  // ── Interfície pública ──────────────────────────────────────────
  canviarEstat(nou) {
    if (!Object.hasOwn(Tasca.#TRANSICIONS, nou)) {
      throw new ErrorDeValidacio(`Estat desconegut: "${nou}".`, 'estat', nou);
    }
    if (!this.#potAnarA(nou)) {
      throw new ErrorDeValidacio(
        `Transició no permesa: "${this.#estat}" → "${nou}".`, 'estat', nou);   // R6
    }
    this.#estat = nou;
    return this;
  }

  estaVencuda(avui) {
    return this.dataLimit < avui && this.oberta;                  // R10
  }

  descripcio(avui) {
    const avis = avui !== undefined && this.estaVencuda(avui) ? ' ⚠ VENÇUDA' : '';
    return `${this.marca} [${this.id}] ${this.titol} · ${this.responsable ?? 'sense assignar'} · ${this.#hores} h${avis}`;
  }
}

const fusteria = new Tasca({
  id: 6, titol: '  Pressupost de la fusteria  ', responsable: 'Iván',
  prioritat: 'alta', etiquetes: ['Fusteria', 'compres', 'FUSTERIA', '  '],
  horesEstimades: 5, dataLimit: '2026-09-05', revisor: 'Marta'
});

console.log(fusteria.titol);                    // 'Pressupost de la fusteria'  ← trim, R2
console.log(fusteria.etiquetes);                // [ 'fusteria', 'compres' ]    ← R9
console.log(fusteria.descripcio('2026-09-20')); // ○ [6] Pressupost de la fusteria · Iván · 5 h ⚠ VENÇUDA
console.log(fusteria.esforc);                   // 15

// Els quatre atacs de l'apartat 1, ara:
try { fusteria.estat = 'feta'; }             catch (e) { console.log('✓ bloquejat:', e.constructor.name); }
try { fusteria.horesEstimades = 500; }       catch (e) { console.log('✓ bloquejat:', e.message); }
try { fusteria.canviarEstat('arxivada'); }   catch (e) { console.log('✓ bloquejat:', e.message); }
try { fusteria.canviarEstat('feta'); }       catch (e) { console.log('✓ bloquejat:', e.message); }

console.log(fusteria.estat, fusteria.horesEstimades);   // 'pendent' 5   ← intacte

'use strict';

class Tasca {
  #estat = 'pendent';

  /** És aquest objecte una Tasca autèntica, creada per aquesta classe? */
  static esTasca(objecte) {
    return #estat in objecte;
  }
}

const real = new Tasca({ id: 1, titol: 'Redissenyar la sala polivalent', horesEstimades: 12, dataLimit: '2026-09-30' });
const impostor = { id: 1, titol: 'Redissenyar la sala polivalent', estat: 'pendent' };

console.log(Tasca.esTasca(real));        // true
console.log(Tasca.esTasca(impostor));    // false
console.log(Tasca.esTasca(null));        // false  (in retorna false, no llança, per a objectes)

const falsificat = Object.create(Tasca.prototype);
console.log(falsificat instanceof Tasca);      // true   ← menteix!
console.log(Tasca.esTasca(falsificat));        // false  ← la marca no es pot falsificar
// falsificat.descripcio();                    // ✗ TypeError: no té els camps privats

class TascaAntiga {
  constructor(estat) { this._estat = estat; }
  get estat() { return this._estat; }
}
const t = new TascaAntiga('pendent');
t._estat = 'arxivada';        // funciona perfectament: res no ho impedeix

function crearTasca(dadesInicials) {
  let estat = 'pendent';                        // ← inaccessible des de fora, de debò
  const transicions = { pendent: ['en-curs'], 'en-curs': ['pendent', 'feta'], feta: [] };

  return {
    id: dadesInicials.id,
    titol: dadesInicials.titol,
    get estat() { return estat; },
    canviarEstat(nou) {
      if (!transicions[estat].includes(nou)) throw new ErrorDeValidacio('Transició no permesa.', 'estat', nou);
      estat = nou;
      return this;
    }
  };
}

const privats = new WeakMap();

class TascaWeak {
  constructor(dades) {
    privats.set(this, { estat: 'pendent' });
    this.id = dades.id;
  }
  get estat() { return privats.get(this).estat; }
  canviarEstat(nou) { privats.get(this).estat = nou; return this; }
}

fusteria.id = 999;      // ✗ res no ho impedeix encara

'use strict';

class Tasca {
  constructor(dades) {
    Object.defineProperty(this, 'id', {
      value: dades.id,
      writable: false,       // no es pot reassignar
      enumerable: true,      // sí que apareix a Object.keys i JSON.stringify
      configurable: false    // no es pot esborrar ni redefinir
    });
    this.titol = dades.titol;
  }
}

const t = new Tasca({ id: 6, titol: 'Pressupost de la fusteria' });

console.log(t.id);                      // 6
// t.id = 999;                          // ✗ TypeError: Cannot assign to read only property 'id'
// delete t.id;                         // ✗ TypeError: Cannot delete property 'id'
console.log(Object.keys(t));            // [ 'id', 'titol' ]
console.log(JSON.stringify(t));         // {"id":6,"titol":"Pressupost de la fusteria"}

console.log(Object.getOwnPropertyDescriptor(t, 'id'));
// { value: 6, writable: false, enumerable: true, configurable: false }

console.log(Object.getOwnPropertyDescriptor(t, 'titol'));
// { value: '…', writable: true, enumerable: true, configurable: true }

Object.defineProperty(Tasca.prototype, 'ocult', { value() { return 1; }, enumerable: false });

'use strict';

class Tauler {
  #tasques = [];
  #nom;

  constructor(nom, tasques = []) {
    this.#nom = nom;
    for (const tasca of tasques) this.afegir(tasca);      // tota entrada passa per la porta oficial
  }

  // ── Lectures ────────────────────────────────────────────────────
  get nom()           { return this.#nom; }
  get total()         { return this.#tasques.length; }
  get tasques()       { return [...this.#tasques]; }              // còpia: mutar-la no afecta el tauler
  get obertes()       { return this.#tasques.filter((t) => t.oberta); }
  get horesTotals()   { return this.#tasques.reduce((s, t) => s + t.horesEstimades, 0); }
  get horesObertes()  { return this.obertes.reduce((s, t) => s + t.horesEstimades, 0); }
  get esforc()        { return this.#tasques.reduce((s, t) => s + t.esforc, 0); }

  cercarPerId(id)     { return this.#tasques.find((t) => t.id === id) ?? null; }
  filtrar(predicat)   { return this.#tasques.filter(predicat); }

  vencudes(avui)      { return this.obertes.filter((t) => t.estaVencuda(avui)); }

  horesPerResponsable() {
    return this.obertes.reduce((acc, t) => {
      const clau = t.responsable ?? 'sense assignar';
      acc[clau] = (acc[clau] ?? 0) + t.horesEstimades;
      return acc;
    }, {});
  }

  resum(avui) {
    return {
      total: this.total, obertes: this.obertes.length,
      horesTotals: this.horesTotals, horesObertes: this.horesObertes,
      vencudes: this.vencudes(avui).length, esforc: this.esforc
    };
  }

  // ── Escriptures (les úniques portes) ────────────────────────────
  afegir(tasca) {
    if (!(tasca instanceof Tasca)) throw new ErrorDeValidacio("Només s'admeten instàncies de Tasca.", 'tasca', tasca);
    if (this.cercarPerId(tasca.id)) throw new ErrorDeValidacio(`Id duplicat: ${tasca.id}.`, 'id', tasca.id);   // R1
    this.#comprovarCarrega(tasca);                                                                             // R7
    this.#tasques.push(tasca);
    return this;
  }

  eliminar(id) {
    const i = this.#tasques.findIndex((t) => t.id === id);
    if (i === -1) throw new ErrorDeValidacio(`No existeix la tasca ${id}.`, 'id', id);
    return this.#tasques.splice(i, 1)[0];
  }

  canviarEstat(id, nou) {
    const tasca = this.cercarPerId(id);
    if (tasca === null) throw new ErrorDeValidacio(`No existeix la tasca ${id}.`, 'id', id);
    tasca.canviarEstat(nou);
    return this;
  }

  // ── Mecanisme intern ────────────────────────────────────────────
  #comprovarCarrega(tasca) {
    if (!tasca.oberta || tasca.responsable === null) return;
    const actual = this.horesPerResponsable()[tasca.responsable] ?? 0;
    if (actual + tasca.horesEstimades > 40) {
      throw new ErrorDeValidacio(
        `${tasca.responsable} arribaria a ${actual + tasca.horesEstimades} h (màxim 40).`, 'horesEstimades', tasca.horesEstimades);
    }
  }
}

const tauler = new Tauler('Taller Nómada', dadesBacklog.map((d) => new Tasca(d)));

console.log(tauler.resum('2026-09-20'));
// { total: 6, obertes: 5, horesTotals: 48, horesObertes: 45, vencudes: 1, esforc: 124 }
console.log(tauler.horesPerResponsable());      // { 'Iván': 25, 'Marta': 6, 'Lucía': 14 }

// Els intents de rodejar l'API:
tauler.tasques.push('això no és una tasca');
console.log(tauler.total);                      // 6   ← es va mutar una còpia, el tauler no se'n va assabentar

try { tauler.afegir('això tampoc'); }
catch (e) { console.log('✓ bloquejat:', e.message); }   // Només s'admeten instàncies de Tasca.

const tasca = new Tasca({
  id: 6, titol: 'Pressupost de la fusteria', responsable: 'Iván',
  prioritat: 'alta', etiquetes: ['fusteria', 'compres'],
  horesEstimades: 5, dataLimit: '2026-09-05', revisor: 'Marta'
});

console.log(JSON.stringify(tasca));
// {"id":6,"titol":"Pressupost de la fusteria","responsable":"Iván","prioritat":"alta","dataLimit":"2026-09-05","revisor":"Marta"}

class Tasca {
  // …tot l'anterior…

  /** Representació serialitzable: inclou el que és privat com a camps públics. */
  toJSON() {
    return {
      id: this.id,
      titol: this.titol,
      responsable: this.responsable,
      prioritat: this.prioritat,
      estat: this.#estat,
      etiquetes: [...this.#etiquetes],
      horesEstimades: this.#hores,
      dataLimit: this.dataLimit,
      revisor: this.revisor
    };
  }

  /** Camí invers: reconstrueix una instància a partir de dades planes. */
  static desDeJSON(dades) {
    return new Tasca(typeof dades === 'string' ? JSON.parse(dades) : dades);
  }
}

console.log(JSON.stringify(tasca));
// {"id":6,…,"estat":"pendent","etiquetes":["fusteria","compres"],"horesEstimades":5,…}

class Tauler {
  // …tot l'anterior…

  toJSON() {
    return { versio: 1, nom: this.#nom, tasques: this.#tasques };   // stringify crida el toJSON de cada tasca
  }

  static importar(text) {
    let dades;
    try {
      dades = JSON.parse(text);
    } catch (error) {
      throw new ErrorDeDades('El backlog no és JSON vàlid.', error);
    }
    if (dades.versio !== 1) throw new ErrorDeDades(`Versió no admesa: ${dades.versio}.`);
    return new Tauler(dades.nom, dades.tasques.map((d) => Tasca.desDeJSON(d)));
  }
}

const text = JSON.stringify(tauler);
const recuperat = Tauler.importar(text);

console.log(recuperat.resum('2026-09-20'));
// { total: 6, obertes: 5, horesTotals: 48, horesObertes: 45, vencudes: 1, esforc: 124 }
console.log(recuperat.cercarPerId(6) instanceof Tasca);   // true  ← instàncies de debò

class Pressupost {
  constructor(limit) {
    this._limit = limit;
    this._linies = [];
  }
  get total() { return this._linies.reduce((s, l) => s + l.quantitat, 0); }
  get linies() { return this._linies; }
  afegir(concepte, quantitat) {
    if (this.total + quantitat > this._limit) throw new Error('Es supera el límit.');
    this._linies.push({ concepte, quantitat });
  }
}

'use strict';

class Resident {
  static #QUOTES = { mensual: 40, diari: 8 };

  #pla;
  #horesReservades = 0;

  constructor(nom, pla) {
    Object.defineProperty(this, 'nom', { value: nom, writable: false, enumerable: true, configurable: false });
    this.pla = pla;                                // passa pel setter: valida
  }

  get pla()               { return this.#pla; }
  get horesReservades()   { return this.#horesReservades; }
  get quota()             { return Resident.#QUOTES[this.#pla]; }
  get horesDisponibles()  { return this.quota - this.#horesReservades; }
  get alDia()             { return this.horesDisponibles > 0; }

  set pla(nou) {
    if (!Object.hasOwn(Resident.#QUOTES, nou)) {
      throw new ErrorDeValidacio(`Pla desconegut: "${nou}".`, 'pla', nou);
    }
    if (this.#horesReservades > Resident.#QUOTES[nou]) {
      throw new ErrorDeValidacio(
        `No es pot passar a "${nou}": ja hi ha ${this.#horesReservades} h reservades i la quota és ${Resident.#QUOTES[nou]}.`,
        'pla', nou);
    }
    this.#pla = nou;
  }

  reservar(hores) {
    if (typeof hores !== 'number' || hores <= 0) {
      throw new ErrorDeValidacio('Les hores han de ser un nombre positiu.', 'hores', hores);
    }
    if (this.#horesReservades + hores > this.quota) {
      throw new ErrorDeValidacio(
        `${this.nom} només té ${this.horesDisponibles} h disponibles.`, 'hores', hores);
    }
    this.#horesReservades += hores;
    return this;
  }
}

const lucia = new Resident('Lucía', 'mensual');
lucia.reservar(14).reservar(12);
console.log(lucia.horesReservades, lucia.horesDisponibles, lucia.alDia);   // 26 14 true

try { lucia.pla = 'diari'; }
catch (e) { console.error(e.message); }   // No es pot passar a "diari": ja hi ha 26 h reservades i la quota és 8.

try { lucia.nom = 'Lucia'; }
catch (e) { console.error(e.constructor.name); }   // TypeError

try { lucia.reservar(20); }
catch (e) { console.error(e.message); }   // Lucía només té 14 h disponibles.

const p = new Pressupost(500);
p.afegir('Tinta serigràfica', 120);
p.linies.push({ concepte: 'Torn nou', quantitat: 9000 });   // ✗ ningú no comprova res
console.log(p.total);                                        // 9120, amb límit 500

'use strict';

class Pressupost {
  #limit;
  #linies = [];

  constructor(limit) {
    if (typeof limit !== 'number' || limit <= 0) {
      throw new ErrorDeValidacio('El límit ha de ser un nombre positiu.', 'limit', limit);
    }
    this.#limit = limit;
  }

  get limit()      { return this.#limit; }
  get total()      { return this.#linies.reduce((s, l) => s + l.quantitat, 0); }
  get disponible() { return this.#limit - this.total; }
  get linies()     { return this.#linies.map((l) => ({ ...l })); }   // còpia de 2 nivells

  afegir(concepte, quantitat) {
    if (this.total + quantitat > this.#limit) {
      throw new ErrorDeValidacio(
        `Es supera el límit: queden ${this.disponible} € i se'n demanen ${quantitat} €.`, 'quantitat', quantitat);
    }
    this.#linies.push({ concepte, quantitat });
    return this;
  }
}

const p = new Pressupost(500);
p.afegir('Tinta serigràfica', 120).afegir('Paper per enquadernar', 80);
p.linies.push({ concepte: 'Torn nou', quantitat: 9000 });   // muta una còpia

console.log(p.total, p.disponible);      // 200 300   ← el pressupost no se'n va assabentar
try { p.afegir('Torn nou', 9000); }
catch (e) { console.error(e.message); }  // Es supera el límit: queden 300 € i se'n demanen 9000 €.

'use strict';

class Tasca {
  // …camps privats i mètodes de l'apartat 6…

  toJSON() {
    return {
      id: this.id, titol: this.titol, responsable: this.responsable,
      prioritat: this.prioritat, estat: this.#estat,
      etiquetes: [...this.#etiquetes], horesEstimades: this.#hores,
      dataLimit: this.dataLimit, revisor: this.revisor
    };
  }

  static desDeJSON(dades) {
    return new Tasca(typeof dades === 'string' ? JSON.parse(dades) : dades);
  }

  clonar() {
    return Tasca.desDeJSON(this.toJSON());
  }
}

const original = new Tasca({
  id: 1, titol: 'Redissenyar la sala polivalent', responsable: 'Iván',
  prioritat: 'alta', estat: 'en-curs', etiquetes: ['espai', 'disseny'],
  horesEstimades: 12, dataLimit: '2026-09-30', revisor: 'Marta'
});

// (a) Sense toJSON es perdrien tres camps. Simulant-ho amb el spread:
console.log(Object.keys({ ...original }));
// [ 'id', 'titol', 'responsable', 'prioritat', 'dataLimit', 'revisor' ]
// falten: estat, etiquetes, horesEstimades

// (b) Amb toJSON, anada i tornada complet
const text = JSON.stringify(original);
const tornada = Tasca.desDeJSON(text);
console.log(tornada.estat, tornada.horesEstimades, tornada.etiquetes);
// 'en-curs' 12 [ 'espai', 'disseny' ]
console.log(tornada instanceof Tasca);         // true

// (c) El clon és independent
const copia = original.clonar();
copia.canviarEstat('feta');
console.log(original.estat, copia.estat);      // 'en-curs' 'feta'
copia.etiquetes = ['espai'];
console.log(original.etiquetes);               // [ 'espai', 'disseny' ]  ← intactes

// (d) structuredClone no pot amb els privats
try { structuredClone(original); }
catch (e) { console.error(e.name); }           // 'DataCloneError'