{
const txt = `[ ] W\n - > [ ] A\n | [ ] X\n - [ ] Y`;
const {html, warnings} = renderFolded(txt);
expect(html).not.toContain('>X<');
expect(warnings).toEqual([{type: 'mixedGate', line: 3, label: 'A'}]);
});
it('lässt den günstigsten Pfad unberührt — Faltung ist reine Ansicht', () => {
const r = roots(`[ ] W (XS)\n - > [ ] A (S)\n | [ ] A1 (XL)\n | [ ] A2 (S)`);
expect([...computeCheapSet(r)].map(n => n.label).sort())
.toEqual(['A', 'A2', 'W']);
});
});
/* Der eingeklappte Knoten vertritt seinen Teilbaum auch auf dem günstigsten
Pfad (SPEC §9, D38-Nachtrag): Sonst überspränge die Pfad-Linie den ganzen
Zweig, als wäre dort nichts zu tun. */
describe('Günstigster Pfad an eingeklappten Knoten', () => {
/* Nimmt die BEREITS geparsten Wurzeln: `collapsedSet` und `cheapSet` prüfen
auf Objektidentität — ein zweiter Parse-Durchlauf liefert andere Objekte
und die Mengen träfen nie zu (dieselbe Falle wie in D28). */
const cheapRender = (r, collapsedSet) =>
renderTreeHtml(r, {t, showDiscarded: false, cheapPath: true,
cheapSet: computeCheapSet(r), collapsedSet: collapsedSet || new Set()}).html;
/* Labels der Stationen (`cheap-leaf`) in Dokumentreihenfolge — genau die
Menge, durch die drawCheapPath() die Linie fädelt. Gelesen aus dem
`aria-label` (erstes Glied = Label): Im Knoteninneren steht bei
eingeklappten Knoten das Falt-Zeichen vor dem Text. */
const stations = html =>
[...html.matchAll(/class="node[^"]*cheap-leaf[^"]*"[^>]*aria-label="([^",]*)/g)]
.map(m => m[1]);
const TXT = `[ ] W (XS)\n - [ ] A (S)\n - [ ] A1 (S)\n - [ ] A2 (S)\n - [ ] B (S)`;
it('macht den eingeklappten Knoten zur Station statt den Zweig zu überspringen', () => {
const r = roots(TXT);
const a = r[0].children[0];
expect(stations(cheapRender(r))).toEqual(['A1', 'A2', 'B']); /* offen */
expect(stations(cheapRender(r, new Set([a])))).toEqual(['A', 'B']); /* zu */
});
it('gibt die Station beim Aufklappen wieder an die Kinder ab', () => {
const r = roots(TXT);
const a = r[0].children[0];
const zu = stations(cheapRender(r, new Set([a])));
const auf = stations(cheapRender(r, new Set()));
expect(zu).not.toContain('A1');
expect(auf).toContain('A1');
expect(auf).not.toContain('A');
});
it('vertritt auch einen Teilbaum, den der Knoten selbst nicht braucht', () => {
/* `+ O` ist entbehrlich und nicht auf dem Pfad — sein Kind wird aber per
Abhängigkeit gezogen (D42). Eingeklappt ist `O` der einzige sichtbare
Griff darauf und darf deshalb weder fehlen noch ausgeblasst sein. */
const txt = `[ ] W (XS)\n - [ ] N (S) :#t\n + [ ] O (S)\n - [ ] #t: T (S)`;
const r = roots(txt);
const o = r[0].children[1];
const set = computeCheapSet(r);
expect([...set].map(n => n.label).sort()).toEqual(['N', 'T', 'W']); /* O selbst nicht */
const {html} = renderTreeHtml(r, {t, showDiscarded: false, cheapPath: true,
cheapSet: set, collapsedSet: new Set([o])});
expect(stations(html)).toContain('O');
});
it('macht einen eingeklappten Knoten ohne Pfad im Teilbaum NICHT zur Station', () => {
const txt = `[ ] W (XS)\n - [ ] N (S)\n + [ ] O (S)\n - [ ] P (S)`;
const r = roots(txt);
const o = r[0].children[1];
const {html} = renderTreeHtml(r, {t, showDiscarded: false, cheapPath: true,
cheapSet: computeCheapSet(r), collapsedSet: new Set([o])});
expect(stations(html)).toEqual(['N']);
});
});
/* Voreinstellung „unter Größe M zuklappen" im Diagramm-Kopf (SPEC §9, D44).
Das Falten selbst liegt in app.js (kein headless-Testziel); geprüft wird
das Prädikat, das entscheidet, WELCHE Knoten es trifft. */
describe('atMostM — Auswahl für „Größe M und kleiner zuklappen"', () => {
const groessen = txt => roots(txt).map(n => [n.label, atMostM(n)]);
it('trifft XS, S und M — offen bleiben nur L, XL, XXL', () => {
expect(groessen('[ ] a (XS)\n[ ] b (S)\n[ ] c (M)\n[ ] d (L)\n[ ] e (XL)\n[ ] f (XXL)'))
.toEqual([['a', true], ['b', true], ['c', true], ['d', false],
['e', false], ['f', false]]);
});
it('trifft Knoten OHNE Größenangabe nicht', () => {
/* Der günstigste Pfad rechnet fehlende Größen als M (D18) — das ist eine
Kostenannahme, keine Aussage des Autors, und faltet hier nichts zu. */
expect(groessen('[ ] ohne')).toEqual([['ohne', false]]);
});
it('ist von Status und Optionalität unabhängig', () => {
expect(groessen('[x] a (S)\n[-] b (S)\n[ ] c (L)').map(([, b]) => b))
.toEqual([true, true, false]);
});
it('gilt auch für Knoten tief im Baum', () => {
const [w] = roots('[ ] W (XL)\n - [ ] A (M)\n - [ ] A1 (XS)\n - [ ] B (L)');
expect([atMostM(w), ...w.children.map(atMostM)]).toEqual([false, true, false]);
expect(atMostM(w.children[0].children[0])).toBe(true);
});
});
/* Zeile -> sichtbarer Vertreter (SPEC §9, D38-Nachtrag 4): Liegt der Knoten
der Cursor-Zeile in einem eingeklappten Teilbaum, vertritt ihn der nächste
sichtbare Vorfahr — für die Hervorhebung wie für den Alt+Klick. */
import { lineTargets } from '../src/model.js';
describe('lineTargets — der eingeklappte Knoten vertritt seine Zeilen', () => {
const byLabel = (ns, label) => {
for(const n of ns){
if(n.label === label) return n;
const hit = byLabel(n.children, label);
if(hit) return hit;
}
return null;
};
const txt = 'A\n - B\n - C\n - D\n - [-] E\n - F';
it('sichtbare Knoten zeigen auf sich selbst', () => {
const r = roots(txt);
const map = lineTargets(r, new Set(), true);
expect(map.get(1)).toBe(1);
expect(map.get(3)).toBe(3);
});
it('Zeilen unter einem eingeklappten Knoten zeigen auf ihn', () => {
const r = roots(txt);
const map = lineTargets(r, new Set([byLabel(r, 'B')]), true);
expect(map.get(2)).toBe(2); /* der eingeklappte selbst ist sichtbar */
expect(map.get(3)).toBe(2);
expect(map.get(4)).toBe(2);
});
it('bei verschachtelter Faltung gilt der ÄUSSERSTE eingeklappte Vorfahr', () => {
const r = roots(txt);
const map = lineTargets(r, new Set([byLabel(r, 'B'), byLabel(r, 'C')]), true);
expect(map.get(4)).toBe(2);
});
it('Beschreibungs- und Fortsetzungszeilen wandern mit ihrem Knoten', () => {
const t2 = 'A\n - B mit einem \\\n langen Titel\n " Notiz';
const r = roots(t2);
const map = lineTargets(r, new Set([byLabel(r, 'A')]), true);
expect(map.get(3)).toBe(1); /* Fortsetzung */
expect(map.get(4)).toBe(1); /* "-Zeile */
});
it('ausgeblendete verworfene Elemente fehlen — sie heben weiter nichts hervor', () => {
const r = roots(txt);
expect(lineTargets(r, new Set(), false).has(6)).toBe(false);
expect(lineTargets(r, new Set(), true).get(6)).toBe(6);
});
});