// Sortieren und Filtern wie in Excel (Henning, 20.10.2026), für jede Tabelle und Liste gleich: // Filter je Spalte über eine Werteliste mit Haken, bei Datumsspalten zusätzlich Zeiträume wie „Diese Woche“, // Sortierung über mehrere Spalten nacheinander, einzelne Zeilen ausblenden. import { type Datum, montagDerWoche, plusMonate, plusTage } from "./datum.js"; export type Richtung = "auf" | "ab"; export interface Ansicht { /** in dieser Reihenfolge: erst nach der ersten Spalte, bei Gleichstand nach der zweiten … */ sort: [string, Richtung][]; /** je Spalte die abgewählten Werte; neue Werte sind also sichtbar */ filter: Record; /** je Datumsspalte ein Zeitraum aus ZEITRAEUME */ zeit: Record; /** ausgeblendete Zeilen (IDs) */ aus: string[]; } export const leereAnsicht = (): Ansicht => ({ sort: [], filter: {}, zeit: {}, aus: [] }); /** Aus Gespeichertem eine vollständige Ansicht machen; Unbrauchbares fällt weg */ export function ansichtAus(x: unknown): Ansicht { const a = (x && typeof x === "object" ? x : {}) as Partial; const strings = (l: unknown) => (Array.isArray(l) ? l.filter((s): s is string => typeof s === "string") : []); const obj = (o: unknown) => (o && typeof o === "object" && !Array.isArray(o) ? (o as Record) : {}); return { sort: (Array.isArray(a.sort) ? a.sort : []).filter((s): s is [string, Richtung] => Array.isArray(s) && typeof s[0] === "string" && (s[1] === "auf" || s[1] === "ab")), filter: Object.fromEntries(Object.entries(obj(a.filter)).map(([k, v]) => [k, strings(v)]).filter(([, v]) => (v as string[]).length)), zeit: Object.fromEntries(Object.entries(obj(a.zeit)).filter(([, v]) => typeof v === "string" && ZEITRAUM_TEXT[v])) as Record, aus: strings(a.aus), }; } export const gleich = (a: Ansicht, b: Ansicht) => JSON.stringify(ansichtAus(a)) === JSON.stringify(ansichtAus(b)); export const LEER = "(Leer)"; /** Zeiträume wie Excels Datumsfilter */ export const ZEITRAEUME: [string, string][] = [ ["vor-heute", "Vor heute"], ["bis-heute", "Bis heute"], ["heute", "Heute"], ["ab-heute", "Ab heute"], ["diese-woche", "Diese Woche"], ["bis-wochenende", "Bis Ende dieser Woche"], ["naechste-woche", "Nächste Woche"], ["letzte-woche", "Letzte Woche"], ["dieser-monat", "Dieser Monat"], ["naechster-monat", "Nächster Monat"], ["letzter-monat", "Letzter Monat"], ["dieses-jahr", "Dieses Jahr"], ]; export const ZEITRAUM_TEXT: Record = Object.fromEntries(ZEITRAEUME); /** Liegt ein Datum im Zeitraum? Ohne Datum nie. Wochen laufen von Montag bis Sonntag. */ export function imZeitraum(art: string, d: Datum | null | undefined, heute: Datum): boolean { if (!d) return false; const mo = montagDerWoche(heute), so = plusTage(mo, 6); const monat = heute.slice(0, 7); switch (art) { case "vor-heute": return d < heute; case "bis-heute": return d <= heute; case "heute": return d === heute; case "ab-heute": return d >= heute; case "diese-woche": return d >= mo && d <= so; case "bis-wochenende": return d <= so; case "naechste-woche": return d >= plusTage(mo, 7) && d <= plusTage(so, 7); case "letzte-woche": return d >= plusTage(mo, -7) && d <= plusTage(so, -7); case "dieser-monat": return d.slice(0, 7) === monat; case "naechster-monat": return d.slice(0, 7) === plusMonate(`${monat}-01`, 1).slice(0, 7); case "letzter-monat": return d.slice(0, 7) === plusMonate(`${monat}-01`, -1).slice(0, 7); case "dieses-jahr": return d.slice(0, 4) === heute.slice(0, 4); default: return true; } } const MONATE = ["Januar", "Februar", "März", "April", "Mai", "Juni", "Juli", "August", "September", "Oktober", "November", "Dezember"]; /** Datumsspalten filtern in der Werteliste nach Monaten */ export const monatVon = (d: Datum | null | undefined) => (d ? d.slice(0, 7) : LEER); export const monatText = (m: string) => (m === LEER ? LEER : `${MONATE[Number(m.slice(5, 7)) - 1]} ${m.slice(0, 4)}`); export interface SpaltenWerte { id: string; art?: "text" | "zahl" | "datum"; /** Wert in der Filterliste (bei Datum der Monat) */ wert: (i: number) => string; /** Wert zum Sortieren (bei Datum das ISO-Datum) */ sort: (i: number) => string | number | null | undefined; } /** Erfüllt Zeile i alle Filter (außer denen der Spalte `ausser`, für die Werteliste dieser Spalte)? */ export function passt(i: number, a: Ansicht, spalten: SpaltenWerte[], heute: Datum, ausser?: string): boolean { for (const s of spalten) { if (s.id === ausser) continue; const ab = a.filter[s.id]; if (ab?.length && ab.includes(s.wert(i))) return false; const z = a.zeit[s.id]; if (z && !imZeitraum(z, s.sort(i) as Datum | null, heute)) return false; } return true; } const leer = (v: unknown) => v === null || v === undefined || v === ""; /** Zwei Werte vergleichen; Leeres steht immer hinten, egal in welcher Richtung */ export function vergleiche(x: unknown, y: unknown, r: Richtung): number { if (leer(x) || leer(y)) return leer(x) === leer(y) ? 0 : leer(x) ? 1 : -1; const n = typeof x === "number" && typeof y === "number" ? x - y : String(x).localeCompare(String(y), "de", { numeric: true, sensitivity: "base" }); return r === "auf" ? n : -n; } /** Indizes in sortierter Reihenfolge; bei Gleichstand bleibt die ursprüngliche Reihenfolge */ export function sortiere(indizes: number[], sort: Ansicht["sort"], spalten: SpaltenWerte[]): number[] { const nach = sort.map(([id, r]) => [spalten.find((s) => s.id === id), r] as const).filter((x): x is [SpaltenWerte, Richtung] => !!x[0]); if (!nach.length) return indizes; return [...indizes].sort((a, b) => { for (const [s, r] of nach) { const c = vergleiche(s.sort(a), s.sort(b), r); if (c) return c; } return a - b; }); }