Laufende Kosten: Kacheln, Gruppen mit Summen, Zellen direkt ändern (0.23.0)
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
This commit is contained in:
@@ -21,11 +21,17 @@ export interface Lage {
|
||||
danach: Posten | null;
|
||||
}
|
||||
|
||||
/** Läuft die Position heute? Die erste Zahlung darf höchstens einen Rhythmus entfernt sein (jährliche also bis 12 Monate) */
|
||||
export function laeuftHeute(k: Pick<LaufendeKosten, "rhythmus" | "start" | "ende">, heute: Datum): boolean {
|
||||
if (k.rhythmus === "einmalig" || (k.ende && k.ende < heute)) return false;
|
||||
return k.start <= plusMonate(heute, k.rhythmus === "jaehrlich" ? 12 : k.rhythmus === "vierteljaehrlich" ? 3 : 1);
|
||||
}
|
||||
|
||||
/** Laufende Kosten eines Monats: monatliche voll, vierteljährliche ein Drittel, jährliche ein Zwölftel; nur was heute läuft */
|
||||
export function laufendJeMonat(laufend: LaufendeKosten[], heute: Datum): Cent {
|
||||
let summe = 0;
|
||||
for (const k of laufend) {
|
||||
if (k.rhythmus === "einmalig" || k.start > plusMonate(heute, 1) || (k.ende && k.ende < heute)) continue;
|
||||
if (!laeuftHeute(k, heute)) continue;
|
||||
summe += k.rhythmus === "monatlich" ? k.betrag : k.rhythmus === "vierteljaehrlich" ? k.betrag / 3 : k.betrag / 12;
|
||||
}
|
||||
return Math.round(summe);
|
||||
|
||||
@@ -16,6 +16,7 @@ import { angebotSeite, angeboteHtml, angeboteSeite, mengenblattSeite, neuesAngeb
|
||||
import { vorlageSeite } from "./mengenblatt.js";
|
||||
import { leistungSeite, stammdatenSeite } from "./stammdaten.js";
|
||||
import { lageKopfHtml, liquiditaetSeite } from "./liquiditaet.js";
|
||||
import { laufendeKostenSeite } from "./laufendekosten.js";
|
||||
import { jahresplanSeite } from "./jahresplan.js";
|
||||
|
||||
|
||||
@@ -528,33 +529,6 @@ async function terminplan(): Promise<void> {
|
||||
ansicht: { lies: gespeicherteAnsicht, setze: ansichtMerken }, auge: [AUGE, AUGE_ZU] });
|
||||
}
|
||||
|
||||
const RHYTHMEN: [string, string][] = [["monatlich", "monatlich"], ["vierteljaehrlich", "vierteljährlich"], ["jaehrlich", "jährlich"], ["einmalig", "einmalig"]];
|
||||
const LK_FELDER: Feld[] = [
|
||||
{ name: "bezeichnung", titel: "Bezeichnung", pflicht: true }, { name: "kategorie", titel: "Kategorie" },
|
||||
{ name: "betrag", titel: "Betrag", art: "euro", pflicht: true }, { name: "rhythmus", titel: "Rhythmus", art: "auswahl", optionen: RHYTHMEN },
|
||||
{ name: "start", titel: "Erste Zahlung", art: "datum", pflicht: true }, { name: "ende", titel: "Endet am", art: "datum" },
|
||||
];
|
||||
|
||||
async function laufendeKosten(): Promise<void> {
|
||||
const neu = async () => (await bearbeiten("laufende-kosten", "Neue laufende Kosten", LK_FELDER, null, { start: heute(), rhythmus: "monatlich" })) && laufendeKosten();
|
||||
seite("Laufende Kosten", { text: "Neue Position", aktion: neu });
|
||||
const zeilen = await api<Zeile[]>("laufende-kosten");
|
||||
const r = Object.fromEntries(RHYTHMEN);
|
||||
const monatlich = (l: Zeile[]) => l.filter((z) => z.rhythmus === "monatlich" && (!z.ende || z.ende >= heute())).reduce((s, z) => s + z.betrag, 0);
|
||||
inhalt.appendChild(liste({
|
||||
schluessel: "laufende-kosten", einheit: ["Position", "Positionen"],
|
||||
spalten: [
|
||||
{ id: "kategorie", titel: "Kategorie", wert: (z) => esc(z.kategorie) }, { id: "bezeichnung", titel: "Bezeichnung", wert: (z) => esc(z.bezeichnung) },
|
||||
{ id: "rhythmus", titel: "Rhythmus", wert: (z) => esc(r[z.rhythmus]), sortWert: (z) => RHYTHMEN.findIndex(([k]) => k === z.rhythmus) },
|
||||
{ id: "start", titel: "Ab", art: "datum", wert: (z) => dat(z.start), sortWert: (z) => z.start, klasse: "optional" },
|
||||
{ id: "ende", titel: "Endet", art: "datum", wert: (z) => dat(z.ende), sortWert: (z) => z.ende, klasse: "optional" },
|
||||
{ id: "betrag", titel: "Betrag", art: "zahl", wert: (z) => euro(z.betrag), sortWert: (z) => z.betrag, klasse: "zahl" },
|
||||
],
|
||||
zeilen, klick: async (z) => (await bearbeiten("laufende-kosten", "Laufende Kosten bearbeiten", LK_FELDER, z)) && laufendeKosten(),
|
||||
fuss: (sichtbar) => `<p>Monatlich${sichtbar.length === zeilen.length ? "" : " (gezeigte Positionen)"}: <strong>${euro(monatlich(sichtbar))}</strong></p>`,
|
||||
}));
|
||||
}
|
||||
|
||||
// G4: Kategorien für Aufgaben, im Auswahlmenü über „Kategorien bearbeiten …“ pflegbar
|
||||
const KATEGORIEN_BEARBEITEN = { text: "Kategorien bearbeiten …", aktion: kategorienBearbeiten };
|
||||
const kategorieOptionen = (liste: Zeile[], leer = "–"): [string, string][] => [["", leer], ...liste.map((k): [string, string] => [k.id, k.name])];
|
||||
@@ -974,7 +948,7 @@ function reiterFuer(s: Sitzung): Reiter[] {
|
||||
const alle: Reiter[] = [
|
||||
["uebersicht", "Übersicht", uebersicht], ["aufgaben", "Aufgaben", aufgaben], ["projekte", "Projekte", projekte],
|
||||
["terminplan", "Terminplan", terminplan], ["personal", "Personal", () => personalSeite()], ["stunden", "Stunden", stundenSeite], ["kontakte", "Kontakte", kontakte],
|
||||
["stammdaten", "Stammdaten", () => stammdatenSeite()], ["liquiditaet", "Liquidität", () => liquiditaetSeite()], ["laufende-kosten", "Laufende Kosten", laufendeKosten],
|
||||
["stammdaten", "Stammdaten", () => stammdatenSeite()], ["liquiditaet", "Liquidität", () => liquiditaetSeite()], ["laufende-kosten", "Laufende Kosten", () => laufendeKostenSeite()],
|
||||
];
|
||||
// Jahresplan und BWA (Stufe 5) nur für den Inhaber
|
||||
if (rolle === "inhaber") alle.push(["jahresplanung", "Jahresplanung", () => jahresplanSeite()], ["benutzer", "Benutzer", () => benutzerSeite(s)], ["daten", "Daten", daten]);
|
||||
|
||||
149
src/web/laufendekosten.ts
Normal file
149
src/web/laufendekosten.ts
Normal file
@@ -0,0 +1,149 @@
|
||||
// Laufende Kosten (Henning, 21.10.2026, Entwurf laufende-kosten/entwurf): oben vier Kacheln, darunter die Liste
|
||||
// nach Gruppe, Kategorie oder ohne gruppiert, mit Summen je Monat und je Jahr. Zellen ändert man direkt wie im
|
||||
// Terminplan, Strg+Z nimmt zurück, eine Zeile lässt sich in eine andere Gruppe ziehen. Ausgeblendete Zeilen zählen
|
||||
// in Summen, Kacheln und Liquidität weiter mit.
|
||||
|
||||
import { type Feld, type Zeile, api, bearbeiten, dat, esc, euro, heute, inhalt, seite } from "./ui.js";
|
||||
import { liste } from "./liste.js";
|
||||
import { termineLaufend } from "../domain/liquiditaet.js";
|
||||
import { laeuftHeute } from "../domain/lage.js";
|
||||
import { plusMonate, plusTage } from "../domain/datum.js";
|
||||
import { formatEuro, parseEuro } from "../domain/geld.js";
|
||||
|
||||
export const RHYTHMEN: [string, string][] = [["monatlich", "monatlich"], ["vierteljaehrlich", "vierteljährlich"], ["jaehrlich", "jährlich"], ["einmalig", "einmalig"]];
|
||||
const RHYTHMUS_TEXT = Object.fromEntries(RHYTHMEN);
|
||||
const LK_FELDER: Feld[] = [
|
||||
{ name: "bezeichnung", titel: "Bezeichnung", pflicht: true }, { name: "kategorie", titel: "Kategorie" }, { name: "gruppe", titel: "Gruppe" },
|
||||
{ name: "betrag", titel: "Betrag", art: "euro", pflicht: true }, { name: "rhythmus", titel: "Rhythmus", art: "auswahl", optionen: RHYTHMEN },
|
||||
{ name: "start", titel: "Erste Zahlung", art: "datum", pflicht: true }, { name: "ende", titel: "Endet am", art: "datum" },
|
||||
];
|
||||
const JE_JAHR: Record<string, number> = { monatlich: 12, vierteljaehrlich: 4, jaehrlich: 1 };
|
||||
|
||||
const glatt = (c: number) => formatEuro(Math.sign(c) * Math.round(Math.abs(c) / 100) * 100).replace(",00 €", " €");
|
||||
|
||||
/** Läuft die Position heute? Gleiche Regel wie für die Mindestgrenze der Liquidität */
|
||||
const laeuft = (z: Zeile, h: string) => laeuftHeute(z as never, h);
|
||||
const jeJahr = (z: Zeile) => Number(z.betrag) * (JE_JAHR[z.rhythmus] ?? 0);
|
||||
const naechste = (z: Zeile, h: string): string | null => termineLaufend({ ...z, betrag: Number(z.betrag), ende: z.ende ?? undefined } as never, h, plusMonate(h, 13))[0] ?? null;
|
||||
const endetBald = (z: Zeile, h: string) => !!z.ende && z.ende >= h && z.ende < plusMonate(h, 6);
|
||||
|
||||
export function summeJeMonat(zeilen: Zeile[], h: string): number {
|
||||
return zeilen.filter((z) => laeuft(z, h)).reduce((s, z) => s + jeJahr(z) / 12, 0);
|
||||
}
|
||||
|
||||
// Rückgängig: jeder Schritt merkt die alten Werte (oder dass die Zeile neu war); gilt bis zum Neuladen
|
||||
type Schritt = { id: string; vorher: Zeile | null };
|
||||
const verlauf: Schritt[] = [];
|
||||
let zuruecknehmen: (() => Promise<void>) | null = null;
|
||||
let tasteDa = false;
|
||||
|
||||
export async function laufendeKostenSeite(oeffnen: { id: string; spalte: string } | null = null): Promise<void> {
|
||||
const [zeilen, e] = await Promise.all([api<Zeile[]>("laufende-kosten"), api<Zeile>("einstellungen").catch(() => ({} as Zeile))]);
|
||||
const h = heute();
|
||||
const y = scrollY;
|
||||
const neuLaden = (weiter: { id: string; spalte: string } | null = null) => laufendeKostenSeite(weiter);
|
||||
seite("Laufende Kosten", { text: "+ Neue Position", aktion: async () => (await bearbeiten("laufende-kosten", "Neue laufende Kosten", LK_FELDER, null, { start: h, rhythmus: "monatlich" })) && neuLaden() });
|
||||
|
||||
const patch = async (z: Zeile, daten: Zeile, weiter: { id: string; spalte: string } | null = null) => {
|
||||
const vorher = Object.fromEntries(Object.keys(daten).map((k) => [k, z[k] ?? null]));
|
||||
await api(`laufende-kosten/${z.id}`, "PATCH", daten);
|
||||
verlauf.push({ id: z.id, vorher });
|
||||
await neuLaden(weiter);
|
||||
};
|
||||
zuruecknehmen = async () => {
|
||||
const s = verlauf.pop();
|
||||
if (!s) return;
|
||||
if (s.vorher) await api(`laufende-kosten/${s.id}`, "PATCH", s.vorher);
|
||||
else await api(`laufende-kosten/${s.id}`, "DELETE");
|
||||
await neuLaden();
|
||||
};
|
||||
if (!tasteDa) {
|
||||
tasteDa = true;
|
||||
document.addEventListener("keydown", (ev) => {
|
||||
if (!(ev.ctrlKey || ev.metaKey) || ev.key.toLowerCase() !== "z" || ev.shiftKey) return;
|
||||
if (!document.querySelector(".lk-seite") || (ev.target as HTMLElement).closest("input, textarea, select")) return;
|
||||
ev.preventDefault();
|
||||
void zuruecknehmen?.();
|
||||
});
|
||||
}
|
||||
|
||||
// Kacheln
|
||||
const monat = summeJeMonat(zeilen, h);
|
||||
const jahr = zeilen.filter((z) => laeuft(z, h)).reduce((s, z) => s + jeJahr(z), 0);
|
||||
const bald = zeilen.flatMap((z) => termineLaufend({ ...z, betrag: Number(z.betrag), ende: z.ende ?? undefined } as never, h, plusTage(h, 30)).map((t) => ({ t, betrag: Number(z.betrag) })));
|
||||
const erste = bald.map((x) => x.t).sort()[0];
|
||||
const gruppen = new Set(zeilen.map((z) => z.gruppe || z.kategorie));
|
||||
const fest = e.mindestgrenzeArt === "fest";
|
||||
const kopf = document.createElement("div");
|
||||
kopf.className = "lk-seite";
|
||||
kopf.innerHTML = `<div class="lk-kacheln">
|
||||
<div class="lk-kachel haupt"><span>Je Monat (umgerechnet)</span><b>${glatt(monat)}</b><small>alle Rhythmen auf den Monat gerechnet</small></div>
|
||||
<div class="lk-kachel"><span>Je Jahr</span><b>${glatt(jahr)}</b><small>${zeilen.length} ${zeilen.length === 1 ? "Position" : "Positionen"} in ${gruppen.size} ${gruppen.size === 1 ? "Gruppe" : "Gruppen"}</small></div>
|
||||
<div class="lk-kachel"><span>Fällig nächste 30 Tage</span><b>${glatt(bald.reduce((s, x) => s + x.betrag, 0))}</b><small>${bald.length ? `${bald.length} ${bald.length === 1 ? "Zahlung" : "Zahlungen"}, nächste ${dat(erste).slice(0, 6)}` : "keine Zahlung"}</small></div>
|
||||
<a class="lk-kachel" href="#liquiditaet"><span>Mindestgrenze Liquidität</span><b>${glatt(fest ? Number(e.mindestreserve) : monat)}</b><small>${fest ? "fester Betrag (in der Liquidität einstellbar)" : "= 1 Monat laufende Kosten"}</small></a>
|
||||
</div>`;
|
||||
inhalt.append(kopf);
|
||||
|
||||
const kategorien = [...new Set(zeilen.map((z) => z.kategorie).filter(Boolean))].sort((a, b) => a.localeCompare(b, "de"));
|
||||
const sum = (l: Zeile[]) => {
|
||||
const m = summeJeMonat(l, h);
|
||||
return { jeMonat: `<b>${euro(Math.round(m))}</b>`, jeJahr: `<b>${glatt(l.filter((z) => laeuft(z, h)).reduce((s, z) => s + jeJahr(z), 0))}</b>` };
|
||||
};
|
||||
const tabelle = liste({
|
||||
schluessel: "laufende-kosten", einheit: ["Position", "Positionen"], klasse: "lk-tabelle",
|
||||
spalten: [
|
||||
{ id: "bezeichnung", titel: "Bezeichnung", text: (z) => z.bezeichnung, wert: (z) => `${esc(z.bezeichnung)}${endetBald(z, h) ? ' <span class="lk-bald">endet bald</span>' : ""}`,
|
||||
bearbeiten: { art: "text", roh: (z) => z.bezeichnung } },
|
||||
{ id: "kategorie", titel: "Kategorie", klasse: "optional", wert: (z) => esc(z.kategorie), bearbeiten: { art: "text", roh: (z) => z.kategorie ?? "", vorschlaege: kategorien } },
|
||||
{ id: "betrag", titel: "Betrag", art: "zahl", klasse: "zahl", wert: (z) => euro(Number(z.betrag)), sortWert: (z) => Number(z.betrag),
|
||||
bearbeiten: { art: "euro", roh: (z) => formatEuro(Number(z.betrag), false) } },
|
||||
{ id: "rhythmus", titel: "Rhythmus", wert: (z) => esc(RHYTHMUS_TEXT[z.rhythmus]), sortWert: (z) => RHYTHMEN.findIndex(([k]) => k === z.rhythmus),
|
||||
bearbeiten: { art: "auswahl", optionen: RHYTHMEN, roh: (z) => z.rhythmus } },
|
||||
{ id: "naechste", titel: "Nächste Zahlung", art: "datum", wert: (z) => dat(naechste(z, h)) || "–", sortWert: (z) => naechste(z, h),
|
||||
bearbeiten: { art: "datum", roh: (z) => naechste(z, h) ?? z.start } },
|
||||
{ id: "ende", titel: "Endet", art: "datum", klasse: "optional", wert: (z) => dat(z.ende) || "–", sortWert: (z) => z.ende, bearbeiten: { art: "datum", roh: (z) => z.ende ?? "" } },
|
||||
{ id: "jeMonat", titel: "je Monat", art: "zahl", klasse: "zahl", sortWert: (z) => (laeuft(z, h) ? jeJahr(z) / 12 : 0),
|
||||
wert: (z) => (z.rhythmus === "einmalig" || (z.ende && z.ende < h) ? "–" : laeuft(z, h) ? euro(Math.round(jeJahr(z) / 12))
|
||||
: `<span class="lk-spaeter" title="beginnt erst am ${dat(z.start)}, zählt noch nicht">${euro(Math.round(jeJahr(z) / 12))}</span>`) },
|
||||
{ id: "jeJahr", titel: "je Jahr", art: "zahl", klasse: "zahl optional", sortWert: (z) => (laeuft(z, h) ? jeJahr(z) : 0),
|
||||
wert: (z) => (laeuft(z, h) ? glatt(jeJahr(z)) : "–") },
|
||||
],
|
||||
zeilen,
|
||||
vorgabe: { sort: [["naechste", "auf"]] },
|
||||
gruppieren: {
|
||||
arten: [{ id: "gruppe", titel: "Gruppe", wert: (z) => z.gruppe ?? "" }, { id: "kategorie", titel: "Kategorie", wert: (z) => z.kategorie ?? "" }],
|
||||
vorgabe: zeilen.some((z) => z.gruppe) ? "gruppe" : "kategorie",
|
||||
neu: async (art, gruppe, bezeichnung) => {
|
||||
const r = await api<Zeile>("laufende-kosten", "POST", { bezeichnung, betrag: 0, rhythmus: "monatlich", start: h, [art]: gruppe || (art === "kategorie" ? "Sonstiges" : null) });
|
||||
verlauf.push({ id: r.id, vorher: null });
|
||||
await neuLaden({ id: r.id, spalte: "betrag" });
|
||||
},
|
||||
ziehen: (z, art, gruppe) => patch(z, { [art]: gruppe || (art === "kategorie" ? "Sonstiges" : null) }),
|
||||
},
|
||||
summen: sum, summenTitel: 'Summe laufende Kosten <small>(ausgeblendete zählen mit)</small>',
|
||||
aendern: async (z, spalte, wert, weiter) => {
|
||||
const w = wert.trim();
|
||||
let daten: Zeile;
|
||||
if (spalte === "bezeichnung") { if (!w) throw new Error("Bitte eine Bezeichnung eintragen."); daten = { bezeichnung: w }; }
|
||||
else if (spalte === "kategorie") daten = { kategorie: w || "Sonstiges" };
|
||||
else if (spalte === "betrag") {
|
||||
try { daten = { betrag: parseEuro(w) }; } catch { throw new Error("Bitte einen Betrag wie 120,50 eintragen."); }
|
||||
} else if (spalte === "rhythmus") daten = { rhythmus: w };
|
||||
// die nächste Zahlung verlegt die Reihe: ab diesem Datum im Rhythmus weiter
|
||||
else if (spalte === "naechste") { if (!w) throw new Error("Bitte ein Datum wählen."); daten = { start: w }; }
|
||||
else if (spalte === "ende") daten = { ende: w || null };
|
||||
else return;
|
||||
await patch(z, daten, weiter);
|
||||
},
|
||||
oeffnen,
|
||||
klick: async (z) => (await bearbeiten("laufende-kosten", "Laufende Kosten bearbeiten", LK_FELDER, z)) && neuLaden(),
|
||||
leiste: () => `<button type="button" class="neben" data-lk="zurueck" title="Letzte Änderung zurücknehmen (Strg+Z)"${verlauf.length ? "" : " disabled"}>↶ Rückgängig</button>`,
|
||||
fuss: () => '<p class="hinweis lk-hilfe">Zelle anklicken = direkt ändern · Enter speichert, Esc bricht ab, Tab springt weiter · Doppelklick = alle Felder · Strg+Z = Rückgängig · Zeile am ⋮⋮ in eine andere Gruppe ziehen = Gruppe ändern</p>',
|
||||
});
|
||||
tabelle.addEventListener("click", (ev) => { if ((ev.target as HTMLElement).closest('[data-lk="zurueck"]')) void zuruecknehmen?.(); });
|
||||
const karte = document.createElement("section");
|
||||
karte.className = "karte lk-karte";
|
||||
karte.append(tabelle);
|
||||
kopf.append(karte);
|
||||
scrollTo(0, y);
|
||||
}
|
||||
199
src/web/liste.ts
199
src/web/liste.ts
@@ -21,6 +21,19 @@ export interface Spalte {
|
||||
kopf?: string;
|
||||
/** ohne Sortieren und Filtern */
|
||||
fest?: boolean;
|
||||
/** Zelle direkt ändern wie im Terminplan: Klick öffnet das Feld, Enter speichert, Esc bricht ab, Tab springt weiter */
|
||||
bearbeiten?: { art: "text" | "euro" | "datum" | "auswahl"; optionen?: [string, string][]; roh: (z: Zeile) => string; vorschlaege?: string[] };
|
||||
}
|
||||
|
||||
/** Zeilen in Gruppen (Henning, 21.10.2026, laufende Kosten): Kopfzeile mit Anzahl und Summen, auf- und zuklappbar */
|
||||
export interface Gruppierung {
|
||||
arten: { id: string; titel: string; wert: (z: Zeile) => string }[];
|
||||
/** Art beim ersten Öffnen; "" = keine */
|
||||
vorgabe: string;
|
||||
/** „+ Position in …“ unter jeder Gruppe: legt mit der eingegebenen Bezeichnung an */
|
||||
neu?: (art: string, gruppe: string, bezeichnung: string) => Promise<void>;
|
||||
/** Zeile am Griff in eine andere Gruppe gezogen */
|
||||
ziehen?: (z: Zeile, art: string, gruppe: string) => Promise<void>;
|
||||
}
|
||||
|
||||
export interface ListenOptionen {
|
||||
@@ -45,9 +58,20 @@ export interface ListenOptionen {
|
||||
klasse?: string;
|
||||
/** Zeilen am Griff ⋮⋮ verschieben (ohne Sortierung): bekommt alle IDs in der neuen Reihenfolge */
|
||||
verschieben?: (ids: string[]) => Promise<void>;
|
||||
gruppieren?: Gruppierung;
|
||||
/** Summen je Spalten-ID für Gruppenköpfe und die Summenzeile; bekommt auch ausgeblendete Zeilen, die zählen mit */
|
||||
summen?: (zeilen: Zeile[]) => Record<string, string>;
|
||||
/** Summenzeile unter der Tabelle mit diesem Titel */
|
||||
summenTitel?: string;
|
||||
/** direkt geänderte Zelle speichern; weiter = Zelle, die danach offen sein soll (Tab). Fehler bleiben im Feld stehen. */
|
||||
aendern?: (z: Zeile, spalte: string, wert: string, weiter: { id: string; spalte: string } | null) => Promise<void>;
|
||||
/** nach dem Neuaufbau diese Zelle gleich zum Ändern öffnen */
|
||||
oeffnen?: { id: string; spalte: string } | null;
|
||||
/** weitere Knöpfe in der Leiste (z. B. Rückgängig) */
|
||||
leiste?: () => string;
|
||||
}
|
||||
|
||||
interface Gespeichert { aktuell?: unknown; name?: string | null; ansichten?: { name: string; ansicht: unknown }[] }
|
||||
interface Gespeichert { aktuell?: unknown; name?: string | null; ansichten?: { name: string; ansicht: unknown }[]; gruppe?: string; zu?: string[] }
|
||||
|
||||
let speicher: Record<string, Gespeichert> = {};
|
||||
const warten = new Map<string, ReturnType<typeof setTimeout>>();
|
||||
@@ -261,6 +285,7 @@ export function liste(o: ListenOptionen): HTMLElement {
|
||||
const zeigen = sortiere(zeigeAus ? gefiltert : gefiltert.filter((i) => !ausSet.has(ids[i]!)), a.sort, sw);
|
||||
const filterIds = beweglich.map((s) => s.id).filter((id) => a.filter[id]?.length || a.zeit[id]);
|
||||
const geaendert = !gleich(a, basis(name));
|
||||
const art = gruppenArt();
|
||||
|
||||
const sortChip = a.sort.length ? `<span class="chip sort"><span>Sortiert: ${a.sort.map(([id, r], n) => `${a.sort.length > 1 ? `${n + 1}. ` : ""}${esc(spalte(id)?.titel ?? id)} ${r === "auf" ? "↑" : "↓"}`).join(" · ")}</span><button type="button" data-a="sort-weg" aria-label="Sortierung entfernen">✕</button></span>` : "";
|
||||
const chips = filterIds.map((id) => `<span class="chip"><button type="button" class="chip-text" data-menue="${id}">${TRICHTER}${esc(spalte(id).titel)}: ${esc(filterText(alleWerte(id), a.filter[id] ?? [], a.zeit[id]))}</button><button type="button" data-chip-weg="${id}" aria-label="Filter ${esc(spalte(id).titel)} entfernen">✕</button></span>`).join("");
|
||||
@@ -268,8 +293,9 @@ export function liste(o: ListenOptionen): HTMLElement {
|
||||
const leiste = leisteZeigen ? `<div class="liste-leiste">
|
||||
${o.klein ? "" : `<button type="button" class="neben ansicht-knopf" data-a="ansichten" aria-haspopup="true">Ansicht: <b>${esc(name ?? "Standard")}</b>${geaendert ? " <i>geändert</i>" : ""} ▾</button>`}
|
||||
${o.klein ? "" : '<button type="button" class="neben nur-schmal" data-a="spalten" aria-haspopup="true">Sortieren und filtern ▾</button>'}
|
||||
${o.gruppieren ? `<button type="button" class="neben ansicht-knopf" data-a="gruppieren" aria-haspopup="true">Gruppieren: <b>${esc(art?.titel ?? "keine")}</b> ▾</button>` : ""}
|
||||
${sortChip}${chips}
|
||||
${geaendert ? '<button type="button" class="verweis" data-a="zuruecksetzen">Zurücksetzen</button>' : ""}</div>` : "";
|
||||
${geaendert ? '<button type="button" class="verweis" data-a="zuruecksetzen">Zurücksetzen</button>' : ""}${o.leiste ? `<span class="leiste-rechts">${o.leiste()}</span>` : ""}</div>` : "";
|
||||
|
||||
const kopf = o.spalten.map((s) => {
|
||||
if (s.fest) return `<th class="${s.klasse ?? ""}">${s.kopf ?? esc(s.titel)}</th>`;
|
||||
@@ -279,25 +305,139 @@ export function liste(o: ListenOptionen): HTMLElement {
|
||||
return `<th class="${s.klasse ?? ""}${r || gefiltertHier ? " aktiv" : ""}"${r ? ` aria-sort="${r === "auf" ? "ascending" : "descending"}"` : ""}>
|
||||
<button type="button" class="th-knopf" data-menue="${s.id}" title="Sortieren und filtern">${s.kopf ?? esc(s.titel)}<span class="th-zeichen">${r ? `${r === "auf" ? "↑" : "↓"}${a.sort.length > 1 ? `<sup>${nr + 1}</sup>` : ""}` : ""}${gefiltertHier ? TRICHTER : ""}<i>▾</i></span></button></th>`;
|
||||
}).join("");
|
||||
const griff = !!o.verschieben && !a.sort.length;
|
||||
const griff = (!!o.verschieben && !a.sort.length) || (!!art && !!o.gruppieren?.ziehen);
|
||||
const griffZelle = griff ? '<td class="griff-spalte"></td>' : "";
|
||||
const zeile = (i: number) => {
|
||||
const x = z[i]!, weg = ausSet.has(ids[i]!);
|
||||
return `<tr data-i="${i}" class="${o.klick ? "klickbar" : ""}${weg ? " ausgeblendet" : ""} ${o.zeilenKlasse?.(x) ?? ""}">${griff ? '<td class="griff-spalte"><span class="zeilen-griff" data-griff title="Anfassen und ziehen, um die Zeile zu verschieben">⋮⋮</span></td>' : ""}${o.spalten.map((s) => `<td class="${s.klasse ?? ""}">${s.wert(x)}</td>`).join("")}
|
||||
return `<tr data-i="${i}"${art ? ` data-g="${esc(art.wert(x))}"` : ""} class="${o.klick ? "klickbar" : ""}${weg ? " ausgeblendet" : ""} ${o.zeilenKlasse?.(x) ?? ""}">${griff ? '<td class="griff-spalte"><span class="zeilen-griff" data-griff title="Anfassen und ziehen, um die Zeile zu verschieben">⋮⋮</span></td>' : ""}${o.spalten.map((s) => `<td class="${s.klasse ?? ""}${s.bearbeiten && o.aendern ? " editierbar" : ""}"${s.bearbeiten && o.aendern ? ` data-b="${s.id}"` : ""}>${s.wert(x)}</td>`).join("")}
|
||||
<td class="auge-spalte"><button type="button" class="auge" data-aus="${esc(ids[i])}" title="${weg ? "Wieder einblenden" : "Zeile ausblenden"}" aria-label="${weg ? "Wieder einblenden" : "Zeile ausblenden"}">${weg ? AUGE : AUGE_ZU}</button></td></tr>`;
|
||||
};
|
||||
// Summenzeile im Spaltenraster: Titel über die Spalten bis zur ersten Summe
|
||||
const summenZellen = (titel: string, werte: Record<string, string>) => {
|
||||
const erste = o.spalten.findIndex((s) => werte[s.id] !== undefined);
|
||||
const span = erste < 1 ? o.spalten.length : erste;
|
||||
return `${griffZelle}<td colspan="${span}">${titel}</td>${o.spalten.slice(span).map((s) => `<td class="${s.klasse ?? ""}">${werte[s.id] ?? ""}</td>`).join("")}<td class="auge-spalte"></td>`;
|
||||
};
|
||||
const breite = o.spalten.length + 1 + (griff ? 1 : 0);
|
||||
let zeilenHtml = zeigen.map(zeile).join("");
|
||||
if (art && zeigen.length) {
|
||||
const schluessel = (i: number) => art.wert(z[i]!);
|
||||
const namen = [...new Set(gefiltert.map(schluessel))].sort((x, y) => (x === "" ? 1 : y === "" ? -1 : x.localeCompare(y, "de", { numeric: true })));
|
||||
const zu = new Set(g.zu ?? []);
|
||||
zeilenHtml = namen.map((k) => {
|
||||
const hier = zeigen.filter((i) => schluessel(i) === k);
|
||||
const alle = gefiltert.filter((i) => schluessel(i) === k);
|
||||
const geschlossen = zu.has(`${art.id}:${k}`);
|
||||
const titel = `<button type="button" class="gruppe-knopf" data-zu="${esc(k)}" aria-expanded="${!geschlossen}"><span class="pfeil">▾</span>${esc(k || "ohne Zuordnung")}</button> <small>· ${alle.length}</small>`;
|
||||
const neu = o.gruppieren?.neu && !geschlossen ? `<tr class="gruppen-neu" data-g="${esc(k)}">${griffZelle}<td colspan="${o.spalten.length}"><button type="button" class="verweis" data-neu="${esc(k)}">+ Position in ${esc(k || "ohne Zuordnung")}</button></td><td class="auge-spalte"></td></tr>` : "";
|
||||
return `<tr class="gruppen-kopf${geschlossen ? " zu" : ""}" data-g="${esc(k)}">${summenZellen(titel, o.summen?.(alle.map((i) => z[i]!)) ?? {})}</tr>${geschlossen ? "" : hier.map(zeile).join("")}${neu}`;
|
||||
}).join("");
|
||||
}
|
||||
const rumpf = !z.length ? `<tr class="leer"><td colspan="${breite}">${esc(o.leer ?? "Noch nichts eingetragen.")}</td></tr>`
|
||||
: !zeigen.length ? `<tr class="leer"><td colspan="${breite}">${versteckt.length ? "Alle passenden Zeilen sind ausgeblendet." : "Nichts passt zu den Filtern."} <button type="button" class="verweis" data-a="${versteckt.length ? "aus-zeigen" : "filter-alle-weg"}">${versteckt.length ? "Einblenden" : "Filter entfernen"}</button></td></tr>`
|
||||
: zeigen.map(zeile).join("");
|
||||
: zeilenHtml;
|
||||
const fussZeile = o.summenTitel && o.summen && z.length ? `<tfoot><tr class="summen-zeile">${summenZellen(o.summenTitel, o.summen(gefiltert.map((i) => z[i]!)))}</tr></tfoot>` : "";
|
||||
const [eins, mehr] = o.einheit ?? ["Eintrag", "Einträge"];
|
||||
const sichtbar = zeigen.length;
|
||||
const anzahl = !z.length ? "" : `${sichtbar === z.length ? `${z.length} ${z.length === 1 ? eins : mehr}` : `${sichtbar} von ${z.length} ${z.length === 1 ? eins : mehr}`}${versteckt.length
|
||||
? ` · ${versteckt.length} ausgeblendet · <button type="button" class="verweis" data-a="aus-zeigen">${zeigeAus ? "wieder verbergen" : "einblenden"}</button>${zeigeAus ? ' · <button type="button" class="verweis" data-a="alle-ein">alle wieder einblenden</button>' : ""}` : ""}`;
|
||||
wurzel.innerHTML = `${leiste}<div class="tabelle-rolle"><table class="${o.klasse ?? ""}"><thead><tr>${griff ? '<th class="griff-spalte" aria-label="Verschieben"></th>' : ""}${kopf}<th class="auge-spalte" aria-label="Ausblenden"></th></tr></thead><tbody>${rumpf}</tbody></table></div>
|
||||
${o.verschieben && a.sort.length && z.length > 1 ? '<p class="hinweis klein-hinweis">Zum Verschieben der Zeilen die Sortierung entfernen.</p>' : ""}
|
||||
wurzel.innerHTML = `${leiste}<div class="tabelle-rolle"><table class="${o.klasse ?? ""}${art ? " gruppiert" : ""}"><thead><tr>${griff ? '<th class="griff-spalte" aria-label="Verschieben"></th>' : ""}${kopf}<th class="auge-spalte" aria-label="Ausblenden"></th></tr></thead><tbody>${rumpf}</tbody>${fussZeile}</table></div>
|
||||
${o.verschieben && a.sort.length && z.length > 1 && !art ? '<p class="hinweis klein-hinweis">Zum Verschieben der Zeilen die Sortierung entfernen.</p>' : ""}
|
||||
${anzahl && (!o.klein || sichtbar !== z.length || versteckt.length) ? `<p class="anzahl">${anzahl}</p>` : ""}${o.fuss ? o.fuss(zeigen.filter((i) => !ausSet.has(ids[i]!)).map((i) => z[i]!)) : ""}`;
|
||||
}
|
||||
|
||||
function gruppenArt() {
|
||||
const gr = o.gruppieren;
|
||||
if (!gr) return null;
|
||||
return gr.arten.find((x) => x.id === (g.gruppe ?? gr.vorgabe)) ?? null;
|
||||
}
|
||||
|
||||
function gruppenMenue(anker: HTMLElement): void {
|
||||
const gr = o.gruppieren!;
|
||||
const jetzt = gruppenArt()?.id ?? "";
|
||||
const m = menue(anker, `<div class="fm-kopf"><b>Gruppieren nach</b><button type="button" class="fm-zu" data-m="zu" aria-label="Schließen">✕</button></div>
|
||||
${[...gr.arten.map((x) => [x.id, x.titel]), ["", "keine"]].map(([id, t]) => `<button type="button" class="fm-zeile${id === jetzt ? " an" : ""}" data-gr="${id}"><span>${id === jetzt ? "✓" : ""}</span>${esc(t)}</button>`).join("")}`);
|
||||
m.addEventListener("click", (ev) => {
|
||||
const b = (ev.target as HTMLElement).closest<HTMLElement>("[data-gr],[data-m]");
|
||||
if (!b) return;
|
||||
menueSchliessen();
|
||||
if (b.dataset.gr === undefined) return;
|
||||
g.gruppe = b.dataset.gr;
|
||||
merken(o.schluessel);
|
||||
zeichne();
|
||||
});
|
||||
}
|
||||
|
||||
// Zellen direkt ändern (Henning, 21.10.2026): wie im Terminplan
|
||||
const editierbar = o.aendern ? o.spalten.filter((s) => s.bearbeiten).map((s) => s.id) : [];
|
||||
function nachbar(i: number, sid: string, schritt: 1 | -1): { id: string; spalte: string } | null {
|
||||
const k = editierbar.indexOf(sid) + schritt;
|
||||
if (k >= 0 && k < editierbar.length) return { id: ids[i]!, spalte: editierbar[k]! };
|
||||
const reihen = [...wurzel.querySelectorAll<HTMLElement>("tbody tr[data-i]")].map((t) => Number(t.dataset.i));
|
||||
const n = reihen[reihen.indexOf(i) + schritt];
|
||||
return n === undefined ? null : { id: ids[n]!, spalte: editierbar[schritt > 0 ? 0 : editierbar.length - 1]! };
|
||||
}
|
||||
function starte(i: number, sid: string): void {
|
||||
const td = wurzel.querySelector<HTMLElement>(`tr[data-i="${i}"] td[data-b="${sid}"]`);
|
||||
const b = o.spalten.find((s) => s.id === sid)?.bearbeiten;
|
||||
if (!td || !b || td.classList.contains("in-arbeit")) return;
|
||||
const x = z[i]!, roh = b.roh(x);
|
||||
const liste = b.vorschlaege?.length ? `<datalist id="vl-${o.schluessel}-${sid}">${b.vorschlaege.map((v) => `<option value="${esc(v)}">`).join("")}</datalist>` : "";
|
||||
td.innerHTML = b.art === "auswahl"
|
||||
? `<select class="zelle-ed">${(b.optionen ?? []).map(([k, t]) => `<option value="${esc(k)}"${k === roh ? " selected" : ""}>${esc(t)}</option>`).join("")}</select>`
|
||||
: `<input class="zelle-ed${b.art === "euro" ? " zahl" : ""}" type="${b.art === "datum" ? "date" : "text"}"${b.art === "euro" ? ' inputmode="decimal"' : ""} value="${esc(roh)}"${liste ? ` list="vl-${o.schluessel}-${sid}"` : ""}>${liste}`;
|
||||
td.classList.add("in-arbeit");
|
||||
td.dataset.seit = String(Date.now());
|
||||
const ed = td.querySelector<HTMLInputElement | HTMLSelectElement>(".zelle-ed")!;
|
||||
ed.focus();
|
||||
if (ed instanceof HTMLInputElement && ed.type === "text") ed.select();
|
||||
let fertig = false;
|
||||
const abschliessen = async (speichern: boolean, weiter: { id: string; spalte: string } | null) => {
|
||||
if (fertig) return;
|
||||
fertig = true;
|
||||
if (!speichern || ed.value === roh) {
|
||||
zeichne();
|
||||
if (weiter) oeffne(weiter);
|
||||
return;
|
||||
}
|
||||
try { await o.aendern!(x, sid, ed.value, weiter); } catch (e) {
|
||||
fertig = false;
|
||||
td.classList.add("fehler-zelle");
|
||||
ed.title = (e as Error).message;
|
||||
ed.focus();
|
||||
}
|
||||
};
|
||||
ed.addEventListener("keydown", (ev) => {
|
||||
const k = (ev as KeyboardEvent).key;
|
||||
if (k === "Enter") { ev.preventDefault(); void abschliessen(true, null); }
|
||||
else if (k === "Escape") { ev.preventDefault(); ev.stopPropagation(); void abschliessen(false, null); }
|
||||
else if (k === "Tab") { ev.preventDefault(); void abschliessen(true, nachbar(i, sid, (ev as KeyboardEvent).shiftKey ? -1 : 1)); }
|
||||
});
|
||||
if (ed instanceof HTMLSelectElement) ed.addEventListener("change", () => void abschliessen(true, null));
|
||||
ed.addEventListener("blur", () => setTimeout(() => { if (!fertig && document.activeElement !== ed) void abschliessen(true, null); }, 0));
|
||||
}
|
||||
function oeffne(w: { id: string; spalte: string }): void {
|
||||
const i = ids.indexOf(w.id);
|
||||
if (i >= 0) starte(i, w.spalte);
|
||||
}
|
||||
// neue Position unter einer Gruppe: erst nur die Bezeichnung, Enter legt an
|
||||
function neueZeile(tr: HTMLElement, gruppe: string): void {
|
||||
const art = gruppenArt();
|
||||
if (!art || !o.gruppieren?.neu) return;
|
||||
const td = tr.querySelector<HTMLElement>("td[colspan]")!;
|
||||
td.innerHTML = `<input class="zelle-ed neu-ed" placeholder="Bezeichnung, Enter legt an, Esc bricht ab" aria-label="Bezeichnung der neuen Position">`;
|
||||
const ed = td.querySelector<HTMLInputElement>("input")!;
|
||||
ed.focus();
|
||||
let fertig = false;
|
||||
ed.addEventListener("keydown", async (ev) => {
|
||||
if (ev.key === "Escape") { fertig = true; zeichne(); }
|
||||
if (ev.key !== "Enter" || !ed.value.trim() || fertig) return;
|
||||
fertig = true;
|
||||
try { await o.gruppieren!.neu!(art.id, gruppe, ed.value.trim()); } catch (e) { fertig = false; ed.title = (e as Error).message; td.classList.add("fehler-zelle"); }
|
||||
});
|
||||
ed.addEventListener("blur", () => setTimeout(() => { if (!fertig && !ed.value.trim()) { fertig = true; zeichne(); } }, 0));
|
||||
}
|
||||
|
||||
function spaltenMenue(id: string, anker: HTMLElement): void {
|
||||
const s = spalte(id);
|
||||
const nr = a.sort.findIndex(([x]) => x === id);
|
||||
@@ -362,22 +502,24 @@ export function liste(o: ListenOptionen): HTMLElement {
|
||||
// Zeilen ziehen wie im Terminplan, mit Zeigerereignissen (auch am Tablet)
|
||||
wurzel.addEventListener("pointerdown", (ev) => {
|
||||
const g = (ev.target as HTMLElement).closest<HTMLElement>("[data-griff]");
|
||||
if (!g || ev.button !== 0 || !o.verschieben) return;
|
||||
const art = gruppenArt();
|
||||
const inGruppe = !!art && !!o.gruppieren?.ziehen;
|
||||
if (!g || ev.button !== 0 || !(o.verschieben || inGruppe)) return;
|
||||
ev.preventDefault();
|
||||
const tr = g.closest<HTMLTableRowElement>("tr[data-i]")!;
|
||||
const von = Number(tr.dataset.i);
|
||||
g.setPointerCapture(ev.pointerId);
|
||||
let ziel: { i: number; nach: boolean } | null = null;
|
||||
let ziel: { i: number; nach: boolean; g?: string } | null = null;
|
||||
const markiere = () => wurzel.querySelectorAll("tr.einfuege-vor,tr.einfuege-nach").forEach((x) => x.classList.remove("einfuege-vor", "einfuege-nach"));
|
||||
const zieh = (e: PointerEvent) => {
|
||||
markiere();
|
||||
tr.classList.add("gezogen");
|
||||
const zeilen = [...wurzel.querySelectorAll<HTMLTableRowElement>("tbody tr[data-i]")];
|
||||
const zeilen = [...wurzel.querySelectorAll<HTMLTableRowElement>(inGruppe ? "tbody tr[data-g]" : "tbody tr[data-i]")];
|
||||
const t = zeilen.find((x) => { const r = x.getBoundingClientRect(); return e.clientY >= r.top && e.clientY < r.bottom; })
|
||||
?? (e.clientY < zeilen[0]!.getBoundingClientRect().top ? zeilen[0] : zeilen.at(-1));
|
||||
if (!t || t === tr) { ziel = null; return; }
|
||||
const r = t.getBoundingClientRect();
|
||||
ziel = { i: Number(t.dataset.i), nach: e.clientY > r.top + r.height / 2 };
|
||||
ziel = { i: Number(t.dataset.i), nach: inGruppe || e.clientY > r.top + r.height / 2, g: t.dataset.g };
|
||||
t.classList.add(ziel.nach ? "einfuege-nach" : "einfuege-vor");
|
||||
};
|
||||
const los = async () => {
|
||||
@@ -385,6 +527,10 @@ export function liste(o: ListenOptionen): HTMLElement {
|
||||
markiere();
|
||||
tr.classList.remove("gezogen");
|
||||
if (!ziel) return;
|
||||
if (inGruppe) {
|
||||
if (ziel.g !== undefined && ziel.g !== art!.wert(z[von]!)) await o.gruppieren!.ziehen!(z[von]!, art!.id, ziel.g);
|
||||
return;
|
||||
}
|
||||
const neu = ids.filter((x) => x !== ids[von]);
|
||||
const pos = neu.indexOf(ids[ziel.i]!) + (ziel.nach ? 1 : 0);
|
||||
neu.splice(pos, 0, ids[von]!);
|
||||
@@ -397,10 +543,19 @@ export function liste(o: ListenOptionen): HTMLElement {
|
||||
|
||||
wurzel.addEventListener("click", (ev) => {
|
||||
const t = ev.target as HTMLElement;
|
||||
const knopf = t.closest<HTMLElement>("[data-menue],[data-aus],[data-chip-weg],[data-a]");
|
||||
const knopf = t.closest<HTMLElement>("[data-menue],[data-aus],[data-chip-weg],[data-a],[data-zu],[data-neu]");
|
||||
if (knopf && wurzel.contains(knopf)) {
|
||||
ev.stopPropagation();
|
||||
if (knopf.dataset.menue) return spaltenMenue(knopf.dataset.menue, knopf);
|
||||
if (knopf.dataset.zu !== undefined) {
|
||||
const k = `${gruppenArt()?.id}:${knopf.dataset.zu}`;
|
||||
const zu = new Set(g.zu ?? []);
|
||||
if (zu.has(k)) zu.delete(k); else zu.add(k);
|
||||
g.zu = [...zu];
|
||||
merken(o.schluessel);
|
||||
return zeichne();
|
||||
}
|
||||
if (knopf.dataset.neu !== undefined) return neueZeile(knopf.closest("tr")!, knopf.dataset.neu);
|
||||
if (knopf.dataset.aus) {
|
||||
const id = knopf.dataset.aus;
|
||||
return setze({ ...a, aus: a.aus.includes(id) ? a.aus.filter((x) => x !== id) : [...a.aus, id] });
|
||||
@@ -419,15 +574,33 @@ export function liste(o: ListenOptionen): HTMLElement {
|
||||
case "alle-ein": zeigeAus = false; return setze({ ...a, aus: a.aus.filter((x) => !ids.includes(x)) });
|
||||
case "ansichten": return ansichtenMenue(knopf);
|
||||
case "spalten": return spaltenAuswahl(knopf);
|
||||
case "gruppieren": return gruppenMenue(knopf);
|
||||
}
|
||||
return;
|
||||
}
|
||||
// Zeile anklicken öffnet sie; Links, Knöpfe und Eingaben in der Zeile behalten ihre eigene Wirkung
|
||||
if (!o.klick || t.closest("a,button,input,select,label,textarea,[data-griff]")) return;
|
||||
if (t.closest("a,button,input,select,label,textarea,[data-griff]")) return;
|
||||
const tr = t.closest<HTMLElement>("tr[data-i]");
|
||||
if (!tr || !wurzel.contains(tr)) return;
|
||||
// mit direkt änderbaren Zellen: Klick ändert die Zelle, Doppelklick öffnet den Dialog
|
||||
if (editierbar.length) {
|
||||
const td = t.closest<HTMLElement>("td[data-b]");
|
||||
if (td) starte(Number(tr.dataset.i), td.dataset.b!);
|
||||
return;
|
||||
}
|
||||
if (o.klick) o.klick(z[Number(tr.dataset.i)]!);
|
||||
});
|
||||
wurzel.addEventListener("dblclick", (ev) => {
|
||||
const t = ev.target as HTMLElement;
|
||||
if (!editierbar.length || !o.klick || t.closest("a,button,[data-griff]")) return;
|
||||
// in einem schon länger offenen Feld wählt der Doppelklick nur ein Wort aus
|
||||
const offen = t.closest<HTMLElement>("td.in-arbeit");
|
||||
if (offen && Date.now() - Number(offen.dataset.seit) > 700) return;
|
||||
const tr = t.closest<HTMLElement>("tr[data-i]");
|
||||
if (tr && wurzel.contains(tr)) o.klick(z[Number(tr.dataset.i)]!);
|
||||
});
|
||||
|
||||
zeichne();
|
||||
if (o.oeffnen) { const w = o.oeffnen; setTimeout(() => oeffne(w)); }
|
||||
return wurzel;
|
||||
}
|
||||
|
||||
@@ -1485,3 +1485,36 @@ input.jp-notiz { width: 100%; min-width: 140px; border: 1px solid var(--linie);
|
||||
.knopf-datei { margin-left: 0; }
|
||||
}
|
||||
.jp-monate .karte-kopf { flex-wrap: wrap; gap: 8px; }
|
||||
|
||||
/* Laufende Kosten (Henning, 21.10.2026): Kacheln, Gruppen mit Summen, Zellen direkt ändern */
|
||||
.lk-kacheln { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); gap: 12px; margin-bottom: 16px; }
|
||||
.lk-kachel { display: flex; flex-direction: column; gap: 2px; background: var(--fl); border: 1px solid var(--linie); border-radius: 10px; padding: 14px 16px; min-width: 0; color: inherit; text-decoration: none; }
|
||||
.lk-kachel.haupt { border-left: 4px solid var(--akzent); }
|
||||
.lk-kachel span { color: var(--leise); font-size: 14px; }
|
||||
.lk-kachel b { font-size: 26px; font-variant-numeric: tabular-nums; }
|
||||
.lk-kachel small { color: var(--leise); }
|
||||
a.lk-kachel:hover { border-color: var(--akzent); }
|
||||
.lk-karte { padding: 14px 16px; }
|
||||
.liste-leiste .leiste-rechts { margin-left: auto; display: inline-flex; gap: 6px; }
|
||||
.liste-leiste .leiste-rechts button:disabled { opacity: 0.5; cursor: default; }
|
||||
table.gruppiert tr.gruppen-kopf td { background: var(--bg); font-weight: 600; border-top: 1px solid var(--linie); }
|
||||
tr.gruppen-kopf small { color: var(--leise); font-weight: 400; }
|
||||
.gruppe-knopf { all: unset; cursor: pointer; display: inline-flex; gap: 6px; align-items: center; font-weight: 600; border-radius: 4px; }
|
||||
.gruppe-knopf:focus-visible { outline: 2px solid var(--akzent); outline-offset: 2px; }
|
||||
.gruppe-knopf .pfeil { display: inline-block; transition: transform 0.15s; color: var(--leise); font-size: 12px; }
|
||||
tr.gruppen-kopf.zu .pfeil { transform: rotate(-90deg); }
|
||||
tr.gruppen-neu td { padding-top: 4px; padding-bottom: 8px; }
|
||||
tr.gruppen-neu .verweis { font-weight: 600; }
|
||||
tfoot tr.summen-zeile td { border-top: 2px solid var(--text); font-weight: 600; padding-top: 10px; }
|
||||
tfoot tr.summen-zeile small { font-weight: 400; color: var(--leise); }
|
||||
td.editierbar { cursor: text; }
|
||||
td.editierbar:hover { box-shadow: inset 0 0 0 1px var(--linie); border-radius: 4px; }
|
||||
td.in-arbeit { padding: 2px 4px; }
|
||||
.zelle-ed { width: 100%; min-width: 90px; box-sizing: border-box; padding: 5px 7px; border: 2px solid var(--akzent); border-radius: 6px; font: inherit; background: var(--fl); color: var(--text); }
|
||||
.zelle-ed.zahl { text-align: right; }
|
||||
td.fehler-zelle .zelle-ed { border-color: var(--warn); background: var(--warnung-bg); }
|
||||
.lk-bald { display: inline-block; margin-left: 6px; padding: 1px 7px; border-radius: 999px; font-size: 12px; background: var(--warnung-bg); color: var(--warnung-text); white-space: nowrap; }
|
||||
.lk-spaeter { color: var(--leise); font-style: italic; }
|
||||
.lk-hilfe { font-size: 13px; margin-top: 8px; }
|
||||
@media (max-width: 1100px) { .lk-kacheln { grid-template-columns: repeat(2, minmax(0, 1fr)); } }
|
||||
@media (max-width: 500px) { .lk-kachel b { font-size: 22px; } .lk-hilfe { display: none; } }
|
||||
|
||||
Reference in New Issue
Block a user