Anpassungen für ATN-Listing

background.js

@@ -315,81 +315,81 @@ browser.runtime.onConnect.addListener((port) => {
   });
 });
 
-browser.runtime.onMessage.addListener(async (nachricht, absender) => {
-  // Nur Nachrichten aus dieser Erweiterung annehmen. Thunderbird lässt
-  // fremde Absender hier zwar ohnehin nicht durch, solange kein
-  // externally_connectable gesetzt ist - die Prüfung kostet nichts und
-  // hält die Zusicherung explizit.
-  if (absender?.id && absender.id !== browser.runtime.id) {
-    return { ok: false, fehler: "Fremder Absender" };
-  }
+/*
+ * Befehle aus den Dialogen.
+ *
+ * Der Listener selbst ist bewusst NICHT async: Ein async-Listener liefert
+ * immer ein Promise zurück und beansprucht damit jede Nachricht - auch
+ * solche, die gar nicht für ihn bestimmt sind. Stattdessen prüft er
+ * synchron, ob die Nachricht aus dieser Erweiterung stammt und einen
+ * bekannten Befehl trägt, und gibt nur dann das Promise des Handlers
+ * zurück. Alles andere lehnt er mit false ab, sodass andere Empfänger
+ * antworten können.
+ * Siehe https://webextension-api.thunderbird.net/en/mv3/guides/runtimeMessaging.html
+ */
+const BEFEHLE = {
+  auftrag: async (n) => auftraege.get(n.nummer) || null,
+
+  einstellungen: async () => ladeEinstellungen(),
+
+  berechtigungPruefen: async () => berechtigungPruefen(),
+
+  suchen: async (n) => (await client()).search(n.query),
+
+  dokument: async (n) => (await client()).document(n.id),
+
+  versionen: async (n) => {
+    const c = await client();
+    return c.versions(await c.document(n.id));
+  },
+
+  stammdaten: async () => {
+    const c = await client();
+    const [tags, korr, typen] = await Promise.all(
+      [c.tags(), c.correspondents(), c.documentTypes()]);
+    return { tags, korr, typen };
+  },
+
+  schrittOeffnen: async (n) => {
+    await dialogOeffnen("schritt", n.auftrag);
+    return undefined;
+  },
+
+  dateiListe: async (n) => dateiListe(n.auftrag),
+
+  ablegenEine: async (n) => ablegenEine(n),
+
+  klassifizieren: async (n) => {
+    const c = await client();
+    const payload = { ...n.payload };
+    payload.correspondent = await aufloesen(c, "correspondents/", n.korrName);
+    payload.document_type = await aufloesen(c, "document_types/", n.typName);
+    await c.patchDocument(n.id, payload);
+    return undefined;
+  },
+
+  anhaengen: async (n) => anhaengenAnEntwurf(n),
+
+  freigabelink: async (n) => freigabelink(n),
+};
+
+async function befehlAusfuehren(handler, nachricht) {
   try {
-    switch (nachricht?.befehl) {
-      case "auftrag":
-        return { ok: true, daten: auftraege.get(nachricht.nummer) || null };
-
-      case "einstellungen":
-        return { ok: true, daten: await ladeEinstellungen() };
-
-      case "berechtigungPruefen":
-        return { ok: true, daten: await berechtigungPruefen() };
-
-      case "suchen": {
-        const c = await client();
-        return { ok: true, daten: await c.search(nachricht.query) };
-      }
-
-      case "dokument": {
-        const c = await client();
-        return { ok: true, daten: await c.document(nachricht.id) };
-      }
-
-      case "versionen": {
-        const c = await client();
-        const doc = await c.document(nachricht.id);
-        return { ok: true, daten: await c.versions(doc) };
-      }
-
-      case "stammdaten": {
-        const c = await client();
-        const [tags, korr, typen] = await Promise.all(
-          [c.tags(), c.correspondents(), c.documentTypes()]);
-        return { ok: true, daten: { tags, korr, typen } };
-      }
-
-      case "schrittOeffnen":
-        await dialogOeffnen("schritt", nachricht.auftrag);
-        return { ok: true };
-
-      case "dateiListe":
-        return { ok: true, daten: dateiListe(nachricht.auftrag) };
-
-      case "ablegenEine":
-        return { ok: true, daten: await ablegenEine(nachricht) };
-
-      case "klassifizieren": {
-        const c = await client();
-        const payload = { ...nachricht.payload };
-        payload.correspondent = await aufloesen(
-          c, "correspondents/", nachricht.korrName);
-        payload.document_type = await aufloesen(
-          c, "document_types/", nachricht.typName);
-        await c.patchDocument(nachricht.id, payload);
-        return { ok: true };
-      }
-
-      case "anhaengen":
-        return { ok: true, daten: await anhaengenAnEntwurf(nachricht) };
-
-      case "freigabelink":
-        return { ok: true, daten: await freigabelink(nachricht) };
-
-      default:
-        return { ok: false, fehler: `Unbekannter Befehl: ${nachricht?.befehl}` };
-    }
+    const daten = await handler(nachricht);
+    return daten === undefined ? { ok: true } : { ok: true, daten };
   } catch (err) {
     return { ok: false, fehler: String(err?.message || err) };
   }
+}
+
+browser.runtime.onMessage.addListener((nachricht, absender) => {
+  // Nur Nachrichten aus dieser Erweiterung mit bekanntem Befehl annehmen.
+  if (absender?.id !== browser.runtime.id) return false;
+  const befehl = nachricht?.befehl;
+  if (typeof befehl !== "string" || !Object.hasOwn(BEFEHLE, befehl)) {
+    return false;
+  }
+  return befehlAusfuehren(BEFEHLE[befehl], nachricht);
 });
 
 async function client() {