dogfather-universe/workspace/assets/js/meldung.js

/* =====================================================================
   WAS DER SERVER SAGT, IN SÄTZEN — 19.09.2026

   Filipe: „keine kryptischen oder technischen Fehlermeldungen, sondern
   klare Aussagen darüber, was passiert ist und wie man das Problem
   lösen kann."

   ---------------------------------------------------------------------
   DAS PROBLEM, NACHGEMESSEN

   Der Server antwortet im Fehlerfall mit `{ fehler: "…" }`. Darin
   stehen ZWEI verschiedene Dinge, und sie sehen von außen gleich aus:

     1. MASCHINENKENNUNGEN — `nicht_verfuegbar`, `nicht_gefunden`,
        `ungueltig`. Sie sind fürs Protokoll gedacht, nicht für Augen.
        Gezählt am 19.09.2026: 43 verschiedene, an 1 300 Stellen.
     2. FERTIGE SÄTZE — z. B. „Woran hast du das gemerkt? Ein Satz
        genügt – ohne ihn ist es beim Gespräch nur noch ein Gefühl."
        Die sind genau richtig so und sollen unverändert durch.

   An 75 Stellen in der Oberfläche stand `textContent = d.fehler` —
   ungefiltert. Wer beim Hochladen einer Datei Pech hatte, las also
   wörtlich `nicht_verfuegbar` auf dem Bildschirm. Ein Mensch ohne
   Vorwissen weiß dann nicht einmal, ob er selbst etwas falsch gemacht
   hat.

   ---------------------------------------------------------------------
   DREI AUSGÄNGE, NICHT ZWEI

   Das ist dieselbe Regel wie überall im Haus — eine Auskunft, die ihre
   Frage nicht beantworten kann, muss das SAGEN und darf nicht schweigen:

     BEKANNTE KENNUNG  → ihr Satz aus der Tabelle unten.
     UNBEKANNTE KENNUNG → der Ersatzsatz des Aufrufers. Sie wird NIE
                          angezeigt. Eine neue Kennung, die noch
                          niemand übersetzt hat, ist ein Fehler im
                          Haus — nicht etwas, das der Benutzer
                          ausbaden soll.
     FERTIGER SATZ     → unverändert durch.

   Woran „Kennung" erkannt wird: nur Kleinbuchstaben, Ziffern und
   Unterstriche, kein Leerzeichen. Ein deutscher Satz hat immer
   Leerzeichen und Großbuchstaben; eine Kennung nie. Die Unterscheidung
   ist damit nicht geraten, sondern entschieden.

   ---------------------------------------------------------------------
   UND WARUM DIE TABELLE NICHT ALTERN KANN

   Eine von Hand gepflegte Liste ist im Haus schon zweimal teuer
   geworden (die abgeschriebene Spaltenliste, die feste Umbruchschwelle).
   Deshalb steht daneben `pruef-meldungen.mjs`: Sie liest ALLE
   Kennungen aus dem Server und wird rot, sobald eine hier fehlt.
   Wer morgen eine neue erfindet, kann sie nicht vergessen.
   ===================================================================== */
(function () {
  'use strict';

  /* Zu jeder Kennung ein Satz, der zwei Dinge tut: sagen, WAS ist —
     und, wo es etwas zu tun gibt, was der nächste Schritt ist.

     KEIN „Fehler 400". Keine Zahl, kein englisches Wort, keine
     Entschuldigung ohne Inhalt. */
  var SAETZE = {
    /* ---- Die drei häufigsten ------------------------------------- */
    nicht_verfuegbar:
      'Der Server antwortet gerade nicht. Nichts wurde gespeichert – '
      + 'versuch es in einer Minute noch einmal.',
    nicht_gefunden:
      'Das gibt es nicht mehr. Wahrscheinlich hat es jemand gelöscht – '
      + 'lade die Seite neu.',
    ungueltig:
      'Mit der Eingabe stimmt etwas nicht. Sieh die Felder noch einmal durch.',

    /* ---- Anmeldung und Zugang ------------------------------------ */
    nicht_angemeldet:
      'Du bist nicht mehr angemeldet. Melde dich noch einmal an.',
    zu_viele_versuche:
      'Zu viele Versuche hintereinander. Warte einen Moment, dann geht es wieder.',
    /* Nicht „etwas Älteres ist offen" — es geht um die Bestätigung des
       eigenen ALTERS beim ersten Anmelden. Beim ersten Hinsehen hatte
       ich es falsch verstanden; der Blick in workspace.js:4864 hat es
       geklärt. */
    alter_offen:
      'Bitte bestätige zuerst dein Alter, dann geht es weiter.',
    eigener_code:
      'Das ist dein eigener Zugang – den kannst du hier nicht neu vergeben.',
    fremde_herkunft:
      'Das wurde aus Sicherheitsgründen abgelehnt. Lade die Seite neu '
      + 'und versuch es noch einmal.',

    /* ---- Darf ich das? ------------------------------------------- */
    nicht_erlaubt: 'Das darfst du hier nicht ändern.',
    nur_leitung:   'Das kann nur DogFather oder die rechte Hand.',
    nur_gruender:  'Das kann nur, wer das Gespräch angelegt hat.',
    hier_nicht:    'An dieser Stelle geht das nicht – abgestimmt wird auf der Wunschliste.',
    gesperrt:      'Dafür ist die Abstimmung zu.',
    geschlossen:   'Der Fall ist abgeschlossen. Hier kann nichts mehr dazukommen.',
    nicht_dran:    'Du bist gerade nicht dran – warte auf die Antwort.',
    leitung_meldet_nicht:
      'Diesen Weg gibt es für das Team. Du liest die Meldungen, du schreibst sie nicht.',
    umgezogen:
      'Diese Seite ist umgezogen. Lade sie neu, dann bist du am richtigen Ort.',

    /* ---- Da fehlt oder stimmt etwas ------------------------------ */
    unvollstaendig: 'Da fehlt noch etwas. Die offenen Stellen sind markiert.',
    leer:           'Da steht noch nichts drin.',
    betreff_fehlt:  'Der Betreff fehlt noch.',
    text_zu_kurz:   'Der Text ist zu kurz – ein ganzer Satz genügt.',
    zu_lang:        'Das ist zu lang. Kürze es etwas.',
    unbrauchbar:    'Damit kann der Server nichts anfangen. Prüf die Eingabe.',
    unbekannte_stufe:
      'Diese Auswahl kennt der Server nicht. Lade die Seite neu.',
    unbekanntes_zeichen:
      'Dieses Zeichen gibt es nicht. Lade die Seite neu.',
    keine_datumsspalte:
      'In der Datei fehlt eine Spalte mit dem Datum. Ohne sie lässt sich nichts zuordnen.',
    keine_zuordnung:
      'Die Zeilen lassen sich niemandem zuordnen. Prüf die Überschriften in der Datei.',

    /* ---- Gab es schon / gibt es nicht ---------------------------- */
    schon_da:           'Das gibt es schon.',
    schon_uebernommen:  'Das hat schon jemand übernommen.',
    schon_entschieden:  'Darüber wurde bereits entschieden.',
    zurueckgenommen:    'Die Nachricht wurde zurückgenommen.',
    nichts_zu_aendern:  'Es gab nichts zu ändern – es steht schon so da.',
    nichts_zu_speichern:'Es gab nichts zu speichern.',
    eintrag_nicht_gefunden: 'Den Eintrag gibt es nicht mehr. Lade die Seite neu.',
    aufgabe_nicht_gefunden: 'Die Aufgabe gibt es nicht mehr. Lade die Seite neu.',
    keine_fassung:      'Dazu gibt es noch keine gespeicherte Fassung.',
    keine_daten:        'Dazu gibt es noch keine Daten.',
    kein_protokoll:     'Dazu gibt es kein Protokoll.',
    kein_block:         'Diesen Bereich gibt es nicht mehr. Lade die Seite neu.',
    kein_hakt:
      'Daraus lässt sich kein Schritt machen – dafür müsste der Punkt auf '
      + '„Da hakt es" stehen.',

    /* ---- Erst das andere zu Ende -------------------------------- */
    uebergang_offen:
      'Es läuft schon ein Übergang. Schließ den erst ab.',
    zu_viele_offen:
      'Du hast schon mehrere Meldungen offen. Warte, bis eine davon beantwortet ist.',
    nur_gruppe_oder_kanal:
      'Das geht nur in einer Gruppe oder einem Kanal, nicht im Zweiergespräch.'
  };

  /* Sieht das wie eine Maschinenkennung aus?
     Nur Kleinbuchstaben, Ziffern, Unterstriche — und kein Leerzeichen.
     Ein Satz aus dem Server hat immer beides nicht. */
  function istKennung(t) {
    return typeof t === 'string' && t.length > 0 && /^[a-z0-9_]+$/.test(t);
  }

  /** Aus dem, was der Server schickt, einen Satz machen.
   *
   *  @param {string|undefined} fehler  was in `{ fehler: … }` stand
   *  @param {string} [ersatz]          Satz für den Fall, dass nichts
   *                                    passt. Er soll zur Stelle
   *                                    passen („Anlegen hat nicht
   *                                    geklappt."), nicht allgemein
   *                                    sein.
   *  @returns {string} immer ein lesbarer Satz, nie eine Kennung.
   */
  window.sagWas = function (fehler, ersatz) {
    var standard = ersatz || 'Das hat nicht geklappt. Versuch es noch einmal.';
    if (!fehler || typeof fehler !== 'string') return standard;
    if (SAETZE[fehler]) return SAETZE[fehler];
    /* UNBEKANNTE KENNUNG: der Ersatzsatz, niemals die Kennung selbst.
       Sie taucht dafür in der Konsole auf — damit sie jemandem
       auffällt, der sie beheben kann, statt dem, der sie nicht
       versteht. */
    if (istKennung(fehler)) {
      try { console.warn('[meldung] Kennung ohne Satz:', fehler); } catch (e) { /* egal */ }
      return standard;
    }
    /* Ein fertiger Satz aus dem Server — unverändert durch. */
    return fehler;
  };

  /* Für die Prüfung, damit sie gegen DIESE Tabelle vergleicht und
     nicht gegen eine abgeschriebene zweite. */
  window.sagWas.SAETZE = SAETZE;
})();

/* =====================================================================
   WENN DIE SEITE GAR NICHT ERST LÄDT — window.ladefehler()

   Filipe, 19.09.2026: „Ladezustände … Es darf keine Sackgassen geben."

   ---------------------------------------------------------------------
   WAS GEMESSEN WURDE (20.09.2026)

   Jede Seite beginnt mit demselben Block:

       try {
         const a = await hole('/workspace/api/ich');
         ...
       } catch { return; }

   Das `catch { return; }` steht auf 13 von 21 Seiten. Fällt das Netz
   aus -- Aufzug, U-Bahn, ein Funkloch --, wirft `fetch`, der Block
   bricht ab, und die Seite bleibt stehen. Für immer.

   Dabei steht auf ihr meistens schon etwas: „Übersicht wird geladen …",
   „Bibliothek wird geladen …", `aria-busy="true"`. Dieser Satz wird nie
   ersetzt. Gemessen: **0 von 32** Stellen setzen `aria-busy` im
   Fehlerfall zurück.

   Im Code steht an einer einzigen Stelle (`start.js`) der richtige
   Satz dazu: „Ein Platzhalter, der nie ersetzt wird, ist eine Lüge mit
   Fortschrittsanzeige." Genau das ist es -- und es galt überall außer
   dort.

   ---------------------------------------------------------------------
   UND ES GAB KEINEN WEG ZURÜCK

   Gesucht über alle 21 Seiten: **kein einziger** „Nochmal versuchen".
   Wer einen Ladefehler hatte, konnte nur F5 drücken -- und auf den 13
   stummen Seiten wusste er nicht einmal, dass es etwas zu wiederholen
   gäbe.

   ---------------------------------------------------------------------
   WAS DIESE FUNKTION TUT

   Sie sucht alles, was gerade „lädt" (`[aria-busy="true"]`), und
   ersetzt es durch drei Dinge: was los ist, was das für den Nutzer
   bedeutet, und einen Knopf, der es noch einmal versucht.

   Findet sie keinen solchen Kasten, baut sie einen -- eine Seite ohne
   Ladeanzeige (chat, steckbrief) soll nicht leer bleiben.

   AUFRUF:
     } catch { ladefehler(); return; }
     } catch { ladefehler({ nochmal: laden }); return; }
   ===================================================================== */
(function () {
  'use strict';

  window.ladefehler = function ladefehler(o) {
    o = o || {};
    const satz = o.satz
      || 'Die Seite konnte gerade nicht geladen werden.';
    const grund = o.grund
      || 'Meistens liegt es am Netz – im Aufzug, in der Bahn, im Funkloch.';

    /* ALLES, WAS GERADE „LAEDT". Abgeleitet, nicht aufgezaehlt: Wer
       morgen einen Ladeplatzhalter einbaut, ist damit automatisch
       abgedeckt. */
    let kaesten = [...document.querySelectorAll('[aria-busy="true"]')];
    if (!kaesten.length) {
      /* Keine Ladeanzeige auf dieser Seite -- dann eine bauen, statt
         den Menschen vor eine leere Seite zu setzen. */
      const ziel = document.querySelector('main') || document.body;
      const kasten = document.createElement('div');
      kasten.className = 'ladefehler';
      ziel.prepend(kasten);
      kaesten = [kasten];
    }

    for (const k of kaesten) {
      /* AUS „BESCHAEFTIGT" WIRD „FERTIG". Sonst meldet ein
         Vorleseprogramm die Flaeche fuer immer als ladend -- und das
         ist schlimmer als gar keine Ansage. */
      k.setAttribute('aria-busy', 'false');
      k.textContent = '';
      k.classList.add('ladefehler');

      const eins = document.createElement('p');
      eins.className = 'ladefehler__satz';
      eins.textContent = satz;
      k.append(eins);

      const zwei = document.createElement('p');
      zwei.className = 'ladefehler__grund';
      zwei.textContent = grund;
      k.append(zwei);

      const knopf = document.createElement('button');
      knopf.type = 'button';
      knopf.className = 'knopf knopf--klein ladefehler__knopf';
      knopf.textContent = 'Nochmal versuchen';
      knopf.addEventListener('click', () => {
        knopf.disabled = true;
        knopf.textContent = 'wird geladen …';
        /* DEN KASTEN SELBST WEGRAEUMEN (20.09.2026).
           Gemessen: Auf `start.html` blieb er nach einem erfolgreichen
           Wiederholen stehen -- `laden()` baut nur seine eigenen
           Bereiche neu auf und weiss von ihm nichts. Ein Fehlerkasten
           ueber einer Seite, die gerade wieder funktioniert, ist
           schlimmer als gar keiner: Er behauptet einen Zustand, der
           vorbei ist. */
        const weg = () => {
          for (const alt of document.querySelectorAll('.ladefehler')) {
            alt.textContent = '';
            alt.classList.remove('ladefehler');
            if (!alt.id && !alt.className) alt.remove();
          }
        };
        /* Wer eine eigene Ladefunktion mitgibt, spart das Neuladen der
           ganzen Seite -- das ist schneller und behaelt die Stelle, an
           der man war. Ohne sie bleibt der ehrliche Notnagel. */
        if (typeof o.nochmal === 'function') {
          Promise.resolve().then(o.nochmal).then(weg).catch(() => location.reload());
        } else {
          location.reload();
        }
      });
      k.append(knopf);
      /* Nur EIN Kasten bekommt den Knopf -- fuenf Knoepfe
         nebeneinander, die dasselbe tun, sind Rauschen. */
      break;
    }

    /* Die uebrigen Ladeanzeigen aufraeumen: Sie duerfen nicht weiter
       „wird geladen …" behaupten, waehrend daneben der Fehler steht.
       Genau diese Doppelung hat die Pruefung an sieben Stellen
       gefunden. */
    for (const k of kaesten.slice(1)) {
      k.setAttribute('aria-busy', 'false');
      k.textContent = '';
    }

    /* UND DIE PLATZHALTER OHNE `aria-busy`. Nicht jede Ladeanzeige
       traegt das Merkmal -- auf `start.html` steht im Ring schlicht
       „wird geladen" in einem <span>. Gesucht wird deshalb nach dem,
       was der Mensch LIEST, nicht nach dem, was im Quelltext
       markiert ist. */
    for (const e of document.querySelectorAll('span, p, div')) {
      if (e.children.length) continue;
      if (!/^\s*(wird geladen|einen Moment)/i.test(e.textContent || '')) continue;
      if (e.closest('.ladefehler')) continue;
      e.textContent = '–';
    }
  };
})();

/* =====================================================================
   WEICHES ROLLEN — ABER NICHT GEGEN DEN WILLEN DES NUTZERS

   `scrollIntoView({ behavior: 'smooth' })` rollt IMMER weich. Die
   Einstellung „Animationen reduzieren" im Betriebssystem schaltet das
   NICHT ab -- der Browser tut sie hier schlicht nicht.

   Wer das eingestellt hat, hat es meist wegen Schwindel oder Migräne
   getan. Eine Seite, die ihm trotzdem unter den Augen wegrollt, ist
   für ihn nicht unschön, sondern unbenutzbar.

   Gemessen am 20.09.2026: 15 Stellen rollen weich, ZWEI davon fragen
   vorher (`checkliste.js`, `kopf.js`). Das Haus kannte die richtige
   Form also -- sie stand nur an dreizehn Stellen nicht.

   Deshalb hier EINMAL, statt dreizehnmal in Kopie.
   ===================================================================== */
window.sanft = function sanft() {
  try {
    return window.matchMedia('(prefers-reduced-motion: reduce)').matches
      ? 'auto' : 'smooth';
  } catch {
    /* Kein matchMedia (sehr alt) -- dann lieber ohne Bewegung. Wer
       nicht fragen kann, soll nicht annehmen. */
    return 'auto';
  }
};