Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
116 lines
5.7 KiB
TypeScript
116 lines
5.7 KiB
TypeScript
// 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<string, string[]>;
|
|
/** je Datumsspalte ein Zeitraum aus ZEITRAEUME */
|
|
zeit: Record<string, string>;
|
|
/** 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<Ansicht>;
|
|
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<string, unknown>) : {});
|
|
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<string, string>,
|
|
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<string, string> = 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;
|
|
});
|
|
}
|