// Generated, do not edit. sha256:8f28252b7948ae2f830773204716ef793d6d67b8fb265b595cb86cfd46f43718
import { describe, it } from 'node:test';
import assert from 'node:assert/strict';

const { compare, sortRows, rowText, filterRows, groupValues, toggleToken, cycleGroupToken } =
  await import('../../client/ui/table-rows.js');

const KOLOMMEN = [
  { key: 'naam' },
  { key: 'bedrag' },
  { key: 'rekening', render: r => `<span class="x">${r.rekening}</span>` },
  { key: 'jaar', group: { value: r => r.jaar, label: v => `Jaar ${v}` } },
];
const RIJ = (naam, bedrag, rekening, jaar) => ({ naam, bedrag, rekening, jaar });

describe('compare', () => {
  it('sorteert getallen als getallen en tekst met de Nederlandse collator', () => {
    assert.ok(compare(2, 10, 'asc') < 0);
    assert.ok(compare('asset 2', 'asset 10', 'asc') < 0, 'numeric: 2 komt vóór 10, niet erna');
  });

  it('ZET LEEG ACHTERAAN, in béide richtingen', () => {
    assert.ok(compare(null, 5, 'asc') > 0);
    assert.ok(compare(null, 5, 'desc') > 0, 'ook omgekeerd blijft leeg onderaan');
    assert.ok(compare(5, null, 'desc') < 0);
    assert.equal(compare(null, null, 'asc'), 0);
  });

  it('behandelt undefined net als null', () => {
    assert.ok(compare(undefined, 5, 'asc') > 0);
  });
});

describe('sortRows', () => {
  const rijen = [RIJ('b', 2), RIJ('a', 10), RIJ('c', null)];

  it('geeft een KOPIE terug en laat de invoer met rust', () => {
    const kopie = [...rijen];
    sortRows(rijen, KOLOMMEN, { key: 'naam', dir: 'asc' });
    assert.deepEqual(rijen, kopie, 'sorteren mag de meegegeven array niet omgooien');
  });

  it('sorteert op de gevraagde kolom', () => {
    const uit = sortRows(rijen, KOLOMMEN, { key: 'naam', dir: 'asc' });
    assert.deepEqual(uit.map(r => r.naam), ['a', 'b', 'c']);
  });

  it('gebruikt sortValue als de kolom die heeft', () => {
    const kols = [{ key: 'naam', sortValue: r => r.bedrag }];
    const uit = sortRows(rijen, kols, { key: 'naam', dir: 'asc' });
    assert.deepEqual(uit.map(r => r.naam), ['b', 'a', 'c'], '2, 10, leeg');
  });

  it('LAAT DE RIJEN STAAN als er op een kolom gesorteerd wordt die niet meer bestaat', () => {
    const uit = sortRows(rijen, KOLOMMEN, { key: 'verdwenen', dir: 'asc' });
    assert.deepEqual(uit.map(r => r.naam), ['b', 'a', 'c']);
  });

  it('doet niets zonder sorteerstand', () => {
    assert.deepEqual(sortRows(rijen, KOLOMMEN, null).map(r => r.naam), ['b', 'a', 'c']);
  });
});

describe('rowText', () => {
  it('neemt de GETOONDE waarde en niet de rauwe', () => {
    const tekst = rowText(RIJ('a', 1, 'Kraken', 2026), KOLOMMEN);
    assert.match(tekst, /kraken/);
  });

  it('vervangt markup door een SPATIE en niet door niets', () => {
    const kols = [{ key: 'x', render: () => 'de<br>bank' }];
    assert.match(rowText({ x: 1 }, kols), /de bank/);
  });

  it('overleeft een lege cel', () => {
    assert.equal(rowText({ naam: null, bedrag: undefined }, [{ key: 'naam' }, { key: 'bedrag' }]).trim(), '');
  });
});

describe('filterRows', () => {
  const rijen = [RIJ('appel', 1, 'Kraken', 2025), RIJ('peer', 2, 'Bitvavo', 2026)];

  it('filtert hoofdletterongevoelig op de zoektekst', () => {
    assert.deepEqual(filterRows(rijen, KOLOMMEN, { search: 'APPEL' }).map(r => r.naam), ['appel']);
  });

  it('geeft alles terug bij een lege of witruimte-zoektekst', () => {
    assert.equal(filterRows(rijen, KOLOMMEN, { search: '   ' }).length, 2);
    assert.equal(filterRows(rijen, KOLOMMEN, {}).length, 2);
  });

  it('verbergt de groepen die op de verbergen-lijst staan', () => {
    const uit = filterRows(rijen, KOLOMMEN, { groupKey: 'jaar', hidden: new Set(['2025']) });
    assert.deepEqual(uit.map(r => r.naam), ['peer']);
  });

  it('NEGEERT EEN GROEPFILTER OP EEN KOLOM DIE NIET MEER BESTAAT', () => {
    const uit = filterRows(rijen, KOLOMMEN, { groupKey: 'verdwenen', hidden: new Set(['x']) });
    assert.equal(uit.length, 2);
  });

  it('combineert zoeken en verbergen', () => {
    const uit = filterRows(rijen, KOLOMMEN, { search: 'e', groupKey: 'jaar', hidden: new Set(['2026']) });
    assert.deepEqual(uit.map(r => r.naam), ['appel']);
  });
});

describe('groupValues', () => {
  const col = KOLOMMEN[3];
  const rijen = [RIJ('a', 1, 'x', 2026), RIJ('b', 1, 'x', 2025), RIJ('c', 1, 'x', 2026)];

  it('geeft elke waarde één keer, met zijn label', () => {
    const uit = groupValues(rijen, col, 'asc');
    assert.deepEqual(uit.map(g => g.token), ['2025', '2026']);
    assert.deepEqual(uit.map(g => g.label), ['Jaar 2025', 'Jaar 2026']);
  });

  it('volgt de gevraagde richting', () => {
    assert.deepEqual(groupValues(rijen, col, 'desc').map(g => g.token), ['2026', '2025']);
  });

  it('valt terug op de waarde zelf als de kolom geen label-functie heeft', () => {
    const kaal = { group: { value: r => r.jaar } };
    assert.deepEqual(groupValues(rijen, kaal, 'asc').map(g => g.label), [2025, 2026]);
  });
});

describe('cycleGroupToken: drie standen', () => {
  it('loopt de cyclus rond en komt terug waar hij begon', () => {
    let s = cycleGroupToken('a', [], []);
    assert.deepEqual(s, { hidden: [], collapsed: ['a'] }, 'eerste klik klapt in');
    s = cycleGroupToken('a', s.hidden, s.collapsed);
    assert.deepEqual(s, { hidden: ['a'], collapsed: [] }, 'tweede klik verbergt');
    s = cycleGroupToken('a', s.hidden, s.collapsed);
    assert.deepEqual(s, { hidden: [], collapsed: [] }, 'derde klik brengt hem helemaal terug');
  });

  it('BRENGT EEN VERBORGEN GROEP TERUG, ook als hij ook nog ingeklapt stond', () => {
    const s = cycleGroupToken('a', ['a'], ['a']);
    assert.deepEqual(s, { hidden: [], collapsed: [] });
  });

  it('laat andere tokens ongemoeid', () => {
    const s = cycleGroupToken('a', ['b'], ['c']);
    assert.deepEqual(s.hidden.sort(), ['b']);
    assert.deepEqual(s.collapsed.sort(), ['a', 'c']);
  });

  it('geeft nieuwe arrays terug en muteert de meegegeven lijsten niet', () => {
    const hidden = ['b'], collapsed = ['c'];
    cycleGroupToken('a', hidden, collapsed);
    assert.deepEqual(hidden, ['b']);
    assert.deepEqual(collapsed, ['c']);
  });
});

describe('toggleToken', () => {
  it('zet erin en haalt eruit', () => {
    assert.deepEqual(toggleToken('a', []), ['a']);
    assert.deepEqual(toggleToken('a', ['a']), []);
  });

  it('overleeft een ontbrekende lijst', () => {
    assert.deepEqual(toggleToken('a', undefined), ['a']);
  });
});