iobroker.alias-workbench 0.9.0 → 0.9.8

package/admin/js/schreiben.js

@@ -6,7 +6,7 @@ import { S } from './zustand.js';
 import { socket } from './verbindung.js';
 import { $, el } from './basis.js';
 import { tr, txt } from './sprache.js';
-import { enums, ladeEnums } from './enums.js';
+import { enums, ladeEnums, enumsUnbekannt } from './enums.js';
 import { enumsVon } from './aufzaehlungen.js';
 import './katalog.js';
 import { holeZweig, indexNeu , nachziehenErledigt } from './objekte.js';
@@ -20,7 +20,8 @@ import {
   kennungtauglich,
   entwurfFuer,
   aliasFuer,
-  knotenDa
+  knotenDa,
+  aboLoesen
 } from './entwurf.js';
 import { zeichneErgebnis } from './ergebnis.js';
 
@@ -221,7 +222,19 @@ export function baueObjekte(e) {
      der Versionen haette nichts mehr zu greifen. */
   var altN = (S.objects[ziel] && S.objects[ziel].native) || {};
   var ausAlias = (e.kanal.indexOf('alias.') === 0);
-  var kanalNative = ausAlias ? JSON.parse(JSON.stringify(altN)) : { quelle: e.kanal };
+  /* Wie bei der Rolle eine Zeile weiter unten: mit dem alten Stand
+     beginnen und nur ueberschreiben, was wirklich beisteuert wird.
+
+     Vorher wurde `native` aus der Quellenansicht vollstaendig durch
+     `{ quelle }` ersetzt; Vorlage, Version und Geraetetyp kamen nur
+     zurueck, wenn gerade eine Vorlage griff. Ist sie geloescht oder
+     umbenannt, liefert `vorschlag` `null` — „Alias aktualisieren" bleibt
+     aber freigeschaltet, und die Herkunft war danach weg: kein Abzeichen
+     „gemerkt", womoeglich eine andere Vorlage bei der naechsten
+     Erkennung, und nichts mehr, woran ein Nachziehen der Versionen
+     greifen koennte. Gemessen 09.09.2026: aus fuenf Feldern wurde eins. */
+  var kanalNative = JSON.parse(JSON.stringify(altN));
+  if (!ausAlias) { kanalNative.quelle = e.kanal; }
   if (e.vorlage) {
     kanalNative.vorlage = e.vorlage;
     kanalNative.vorlageVersion = e.vorlageVersion;
@@ -378,6 +391,36 @@ export function zuSchreiben(alleAusgaenge) {
      Entwurf, benannt nach dem Kanal — nicht nach seiner Nummer. Aus
      „Kanal 1" wird `Licht_Bar`, weil das der Name ist, den jemand ihm
      gegeben hat. */
+  /* Raum und Funktion gehoeren an jeden Kanal, nicht nur an den
+     gezeigten.
+
+     Die Teil-Entwuerfe entstehen frisch aus `entwurfFuer` bzw.
+     `vorschlag` und trugen keins von beidem. `enumAenderungen` baute
+     deshalb fuer keinen einzigen Kanal ein Enum-Objekt: Wer oben einen
+     Raum einstellte und „Alle erzeugen" drueckte, bekam Kanaele ohne
+     Raum — der Einzelweg setzte ihn, der Sammelweg nicht.
+
+     Schlimmer war der zweite Fall: Fuer einen fremden Ausgang galt
+     `gewaehlt === ''`. Stand dessen Alias schon in einem Raum, fand ihn
+     `enumsVon`, und das gebaute Objekt trug ihn dort **aus**. Aus „ich
+     lege die anderen Ausgaenge auch an" wurde „ich nehme ihnen ihren
+     Raum weg" (gemessen 09.09.2026 an der Steckdosenleiste: Ausgang 2
+     verlor `enum.rooms.WBG30`).
+
+     Was ein Kanal schon hat, behaelt er — dieselbe Regel wie ueberall
+     sonst: der Bestand schlaegt den Vorschlag. Nur wer keine Zuordnung
+     hat, bekommt die eingestellte. */
+  var enumsUebertragen = function (v) {
+    if (!v || !v.ziel) { return v; }
+    [['rooms', 'raum', 'raumHer'], ['functions', 'funktion', 'funktionHer']]
+      .forEach(function (a) {
+        var eigen = enumsVon(v.ziel, a[0])[0] || '';
+        v[a[1]] = eigen || S.entwurf[a[1]] || '';
+        v[a[2]] = eigen ? 'bestand' : (v[a[1]] ? 'hand' : '');
+      });
+    return v;
+  };
+
   if (alleAusgaenge && S.entwurf.kanalGeraete && S.entwurf.kanalGeraete.length > 1) {
     /* Ein Ordner fuer das Geraet, darunter je Kanal ein Kanal — dieselbe
        Form, die die Tasmota-Mehrfachvorlage seit jeher erzeugt. */
@@ -387,10 +430,18 @@ export function zuSchreiben(alleAusgaenge) {
       var v = entwurfFuer(k.id, gem, S.entwurf.gemeinsamMitPlatz);
       if (!v) { return null; }
       v.zielOrdner = ordner;
-      v.zielName = k.name;
-      v.ziel = ordner + '.' + k.name;
+      /* Die Kennung, nicht der Anzeigename. „Licht Bar, oben" ergab eine
+         Kennung mit Leerzeichen und Komma, „Kueche.Decke" sogar eine
+         zusaetzliche Ebene samt Zwischenordner. Und der js-controller
+         lehnt so etwas nicht ab, er saeubert still: aus
+         `alias.0.wb[pruef]` wurde `alias.0.wb_pruef_`, der Rueckruf
+         meldete `null`. Das Objekt entstuende also unter einer anderen
+         Kennung als angezeigt (gemessen 08.09.2026). Der Name bleibt
+         davon unberuehrt — er steht als Beschriftung im Objekt. */
+      v.zielName = k.kennung || k.name;
+      v.ziel = ordner + '.' + v.zielName;
       uebernehmeBestand(v);
-      return v;
+      return enumsUebertragen(v);
     }).filter(Boolean);
   }
   if (!alleAusgaenge || !S.entwurf.instanzen || S.entwurf.instanzen.length < 2) { return [S.entwurf]; }
@@ -401,11 +452,41 @@ export function zuSchreiben(alleAusgaenge) {
       v.zielOrdner = S.entwurf.zielOrdner;
       v.zielName = ausgangName(v, n);
       v.ziel = v.zielOrdner + '.' + v.zielName;
+      enumsUebertragen(v);
     }
     return v;
   }).filter(Boolean);
 }
 
+/* Ein Objekt in die Liste, ohne ein vorhandenes zu verlieren.
+
+   Bei „Alle erzeugen" bauen mehrere Teil-Entwuerfe dasselbe Enum-Objekt,
+   jeder mit seiner eigenen Kennung darin. Die frueher hier stehende
+   Zeile `if (!liste.some(x => x.id === o.id)) liste.push(o)` warf das
+   zweite weg - von vier Ausgaengen landete einer im Raum, die anderen
+   drei fielen still unter den Tisch.
+
+   Gewoehnliche Objekte bleiben beim ersten: dort ist die Kennung
+   eindeutig, ein zweites waere derselbe Kanal. Nur Aufzaehlungen werden
+   vereinigt, und dabei gilt: eingetragen schlaegt ausgetragen. Ein
+   Mitglied, das ein Entwurf haben will, nimmt ihm kein anderer weg. */
+function sammle(liste, o) {
+  var vorh = null;
+  liste.forEach(function (x) { if (!vorh && x.id === o.id) { vorh = x; } });
+  if (!vorh) { liste.push(o); return; }
+  if (!o.istEnum || !vorh.istEnum) { return; }
+  var m = ((vorh.obj.common || {}).members || []).slice();
+  ((o.obj.common || {}).members || []).forEach(function (x) {
+    if (m.indexOf(x) === -1) { m.push(x); }
+  });
+  m.sort();
+  vorh.obj.common.members = m;
+  vorh.dazu = vorh.dazu || o.dazu;
+  vorh.weg = vorh.weg && o.weg;
+  vorh.ikonDazu = vorh.ikonDazu || o.ikonDazu;
+  vorh.neu = vorh.neu && o.neu;
+}
+
 export function zeigeTrockenlauf(alleAusgaenge) {
   if (!S.entwurf) { return; }
   S.trockenAlle = !!alleAusgaenge;
@@ -420,9 +501,7 @@ export function zeigeTrockenlauf(alleAusgaenge) {
   var liste = [];
   var probleme = [];
   entwuerfe.forEach(function (en) {
-    baueObjekte(en).forEach(function (o) {
-      if (!liste.some(function (x) { return x.id === o.id; })) { liste.push(o); }
-    });
+    baueObjekte(en).forEach(function (o) { sammle(liste, o); });
     pruefeSchreiben(en).forEach(function (pr) { probleme.push(pr); });
   });
 
@@ -521,6 +600,17 @@ export function zeigeTrockenlauf(alleAusgaenge) {
     body.appendChild(zwK);
   }
 
+  /* Die Aufzaehlungen sind gerade nicht bekannt — dann wird auch keine
+     geschrieben. Das gehoert hierher und nicht in eine Sperre: der Alias
+     selbst braucht sie nicht, und aus einem stillen Datenverlust eine
+     stille Blockade zu machen waere kein Fortschritt (P8). */
+  if (enumsUnbekannt() && S.entwurf && (S.entwurf.raum || S.entwurf.funktion)) {
+    var ek = el('div', 'aside w');
+    ek.style.marginBottom = '11px';
+    ek.appendChild(el('b', null, tr('write.enumsUnknown')));
+    body.appendChild(ek);
+  }
+
   if (weg.length) {
     var wk = el('div', 'card');
     wk.style.marginBottom = '11px';
@@ -582,10 +672,20 @@ export function zeigeTrockenlauf(alleAusgaenge) {
         kn2.disabled = true;
         kn2.textContent = tr('write.writing');
         var offen2 = fehlend.length;
+        var mqFehler = [];
         fehlend.forEach(function (fid) {
           var t2 = fid.split('.cmnd.');
-          mqttEinzelnStill(t2[0], t2[1], function () {
+          mqttEinzelnStill(t2[0], t2[1], function (err) {
+            if (err) { mqFehler.push(fid + ': ' + err); }
             if (--offen2 === 0) {
+              /* Was nicht entstanden ist, wird benannt — nicht gezaehlt.
+                 Der Trockenlauf sperrt danach ohnehin wieder, aber ohne
+                 diesen Satz suchte man den Grund am falschen Ende. */
+              if (mqFehler.length) {
+                kn2.disabled = false;
+                kn2.textContent = tr('write.retry');
+                kn2.title = mqFehler.join(' | ');
+              }
               /* Erst den Entwurf neu aufbauen lassen, dann den
                  Trockenlauf noch einmal rechnen. Sofort geoeffnet zeigte
                  er den Rohentwurf, weil die Vorlage noch nicht wieder
@@ -811,6 +911,30 @@ export function zeichneLoeschen() {
   hin.textContent = tr('del.hint');
   body.appendChild(hin);
 
+  /* Liegen eigene Kanaele darunter?
+
+     Der Umfang nimmt alles unterhalb des Praefixes. Bei einem
+     `device`-Container sind das auch fremde Alias-Kanaele — ganze
+     Geraete, die mit dem gemeinten nichts zu tun haben. Die Liste zeigt
+     sie zwar mit Typ, aber der Hinweistext sprach nur von „Datenpunkten
+     darunter", und die Zahl oben sagt nur, wie viele Zeilen es sind.
+     Wer sie zaehlt, weiss nicht, dass er drei Geraete mitnimmt. */
+  var kanaeleDrunter = alle.filter(function (id) {
+    if (id === ziel) { return false; }
+    var o = S.objects[id];
+    return o && (o.type === 'channel' || o.type === 'device');
+  });
+  if (kanaeleDrunter.length) {
+    var kw = el('div', 'aside w');
+    kw.style.marginBottom = '11px';
+    kw.appendChild(el('b', null, tr('del.channelsBelow', kanaeleDrunter.length)));
+    var kl = el('div', 'hint');
+    kl.style.marginTop = '4px';
+    kl.textContent = kanaeleDrunter.map(function (x) { return x.slice(ziel.length + 1); }).join(', ');
+    kw.appendChild(kl);
+    body.appendChild(kw);
+  }
+
   var gesch = geschwisterVon(ziel);
   if (gesch.length) {
     var gw = el('div', 'aside');
@@ -888,10 +1012,11 @@ export function loescheAlias() {
   b.disabled = true;
   b.textContent = tr('write.writing');
 
-  var offen = alle.length, fehler = [];
+  var offen = alle.length, fehler = [], wirklichWeg = [];
   alle.forEach(function (id) {
     socket.emit('delObject', id, function (err) {
       if (err) { fehler.push(id + ': ' + err); }
+      else { wirklichWeg.push(id); }
       if (--offen === 0) {
         var body = $('#del-body');
         body.textContent = '';
@@ -903,8 +1028,23 @@ export function loescheAlias() {
           m.appendChild(el('b', null, tr('del.done', alle.length)));
         }
         body.appendChild(m);
-        alle.forEach(function (x) { delete S.objects[x]; });
-        S.keysSorted = Object.keys(S.objects).sort();
+        /* Nur austragen, was wirklich weg ist.
+
+           Vorher fielen alle Kennungen aus dem eigenen Bestand, egal ob
+           das Loeschen geklappt hatte. Was in der Datenbank stehenblieb,
+           war danach ueber die Werkbank nicht mehr zu greifen - sie hielt
+           es fuer geloescht (gemessen 09.09.2026: `…Neu.WORKING` stand am
+           System, fehlte aber im Vorrat). */
+        wirklichWeg.forEach(function (x) { delete S.objects[x]; });
+        /* `indexNeu()` statt nur zu sortieren.
+
+           An vier Stellen stand hier `S.keysSorted = Object.keys(...)`,
+           obwohl `indexNeu` importiert ist. Das raeumt zusaetzlich
+           `S.kleinIndex` und zieht die Objektzahl in der Kopfzeile nach.
+           Ohne das behielt die Karte geloeschte Kennungen — `hatPunkt`
+           lieferte Treffer auf Punkte, die es nicht mehr gab —, und die
+           Zahl oben blieb stehen (gefunden 09.09.2026). */
+        indexNeu();
 
         /* Ordner, die dadurch leer geworden sind, mitnehmen — aber nur
            die eigenen Zwischenebenen unterhalb von alias.0, und nur
@@ -920,11 +1060,22 @@ export function loescheAlias() {
         } else {
           b.hidden = true;
         }
+        /* Nach einem Teilfehler wird nicht aufgeraeumt und das Ziel
+           bleibt stehen: „Noch einmal versuchen" ruft `loescheAlias`,
+           und das beginnt mit `if (!S.loeschZiel) return;` — ohne Ziel
+           war der Knopf eine Attrappe. Aufraeumen waere ohnehin falsch,
+           solange noch etwas darunter liegt. */
+        if (fehler.length) {
+          zeichneBaum();
+          zeichneErgebnis();
+          return;
+        }
         leereEnumsRaeumen(enumsMitzunehmen, alle, function () {
           leereOrdnerRaeumen(ziel, function () {
             S.loeschZiel = null;
             S.entwurf = null;
             S.current = null;
+            aboLoesen();
             zeichneBaum();
             zeichneErgebnis();
           });
@@ -1174,11 +1325,28 @@ export function zeigeVerlegen(altVorgabe, zielVorgabe) {
       b.disabled = true;
       return;
     }
-    if (S.objects[neu]) {
+    /* Ein Ziel, das es schon gibt — auch eines ohne eigenes
+       Kanalobjekt. `S.objects` allein reicht nicht: legt man Aliaspunkte
+       von Hand im Admin an, entsteht `alias.0.X.Y.PUNKT`, ohne dass
+       `alias.0.X.Y` als Objekt existiert. Der Baum zeigt den Knoten
+       trotzdem, und das Verlegen schrieb bisher mitten hinein und
+       ueberschrieb vorhandene Punkte gleichen Namens (E31, T23). */
+    if (knotenDa(neu)) {
       vorschau.appendChild(el('div', 'aside w', tr('move.exists', neu)));
       b.disabled = true;
       return;
     }
+    /* Und kein Ziel, das mit der Quelle verschachtelt ist.
+
+       `alias.0.X` nach `alias.0.X.Sub`: `verlegeUmfang` enthaelt
+       `alias.0.X`, und das Loeschen am Ende nimmt genau den Elternknoten
+       des eben verlegten Alias mit. Umgekehrt genauso — dann laege das
+       Ziel im Umfang und wuerde gleich wieder geloescht. */
+    if (neu.indexOf(alt + '.') === 0 || alt.indexOf(neu + '.') === 0) {
+      vorschau.appendChild(el('div', 'aside w', tr('move.nested')));
+      b.disabled = true;
+      return;
+    }
     b.disabled = false;
 
     var umfang = verlegeUmfang(alt);
@@ -1360,7 +1528,7 @@ export function verlegeAlias(alt, neu) {
            blieb aus, und ein zweites Verlegen war nicht moeglich. */
         S.objects[zielId] = o;
       }
-      if (--offen === 0) { S.keysSorted = Object.keys(S.objects).sort(); weiter(); }
+      if (--offen === 0) { indexNeu(); weiter(); }
     });
   });
 
@@ -1386,7 +1554,16 @@ export function verlegeAlias(alt, neu) {
     enumArbeit.forEach(function (a) {
       socket.emit('setObject', a.id, a.obj, function (err) {
         if (err) { fehler.push(a.id + ': ' + err); }
-        if (--offen2 === 0) { loeschen(); }
+        if (--offen2 === 0) {
+          /* Derselbe Abbruch wie eine Stufe darueber: geht etwas schief,
+             wird nicht geloescht. Vorher lief `loeschen()` trotzdem —
+             der alte Alias war weg, der neue stand in keiner Aufzaehlung,
+             und die Zuordnung war damit verloren (gemessen 09.09.2026:
+             `enum.rooms.WBP3` blieb leer zurueck). Zwei Aliase sind
+             unschoen, aber reparierbar; eine verlorene Zuordnung nicht. */
+          if (fehler.length) { return melden(fehler); }
+          loeschen();
+        }
       });
     });
   }
@@ -1400,7 +1577,7 @@ export function verlegeAlias(alt, neu) {
         if (err) { fehler.push(id + ': ' + err); }
         if (--offen3 === 0) {
           weg.forEach(function (x) { delete S.objects[x]; });
-          S.keysSorted = Object.keys(S.objects).sort();
+          indexNeu();
           leereOrdnerRaeumen(alt, function () {
             S.current = neu;
             S.entwurf = null;
@@ -1428,9 +1605,15 @@ export function verlegeAlias(alt, neu) {
     body.appendChild(m);
     /* Nur in diesem Dialog verschwinden lassen - beim naechsten Oeffnen
        baut ihn `zeigeVerlegen` wieder auf. Vorher blieb er dauerhaft
-       versteckt, und ein zweites Verlegen ging nicht mehr. */
-    b.hidden = true;
+       versteckt, und ein zweites Verlegen ging nicht mehr.
+
+       Nach einem Fehlschlag bleibt er als „Noch einmal versuchen" stehen:
+       das Neue ist dann schon angelegt, das Alte steht noch, und ein
+       zweiter Anlauf schreibt beides gefahrlos nach - genau das, was ein
+       kurzer Aussetzer beim Schreiben der Aufzaehlung braucht. */
     b.disabled = false;
+    if (f.length) { b.hidden = false; b.textContent = tr('write.retry'); }
+    else { b.hidden = true; }
     ladeEnums(function () {
       zeichneBaum();
       /* Den Alias unter der neuen Kennung wieder aufschlagen.
@@ -1473,7 +1656,7 @@ export function leereOrdnerRaeumen(weg, fertig) {
     if (!o || o.type !== 'folder' || belegt) { return fertig(); }
     socket.emit('delObject', pfad, function () {
       delete S.objects[pfad];
-      S.keysSorted = Object.keys(S.objects).sort();
+      indexNeu();
       weiter();
     });
   })();
@@ -1487,9 +1670,7 @@ export function schreibeObjekte() {
   var liste = [];
   var schlecht = 0;
   entwuerfe2.forEach(function (en) {
-    baueObjekte(en).forEach(function (o) {
-      if (!liste.some(function (x) { return x.id === o.id; })) { liste.push(o); }
-    });
+    baueObjekte(en).forEach(function (o) { sammle(liste, o); });
     schlecht += pruefeSchreiben(en).length;
   });
   if (schlecht) { return; }
@@ -1560,7 +1741,11 @@ export function schreibeObjekte() {
       }
       $('#btn-dry-write').hidden = true;
     }
-    S.loeschListe = [];
+    /* Nur bei Erfolg. Der Wiederholen-Knopf ruft `schreibeObjekte`
+       direkt, und das filtert dann eine leere Liste: die verwaisten
+       Punkte blieben fuer immer stehen, und die Erfolgsmeldung zaehlte
+       sie nicht mehr mit (gemessen 09.09.2026). */
+    if (!fehler.length) { S.loeschListe = []; }
 
     /* Die Marke „geaendert“ hat ihre Aufgabe erfuellt.
 

package/admin/js/sprache.js

@@ -55,11 +55,27 @@ export function ladeSprache(fertig) {
   var beantwortet = false;
   socket.emit('getObject', 'system.config', function (err, obj) {
     if (beantwortet) { return; }
-    beantwortet = true;
-    /* Der Expertenmodus steht an derselben Stelle — einmal fragen reicht
-       fuer beides. */
-    expertenVorgabe = !!(!err && obj && obj.common && obj.common.expertMode);
+    /* Auch eine spaete Antwort gilt noch.
+
+       Nach 2,5 Sekunden geht es ohne weiter — richtig, sonst haengt der
+       Reiter an einem stillen Controller. Die Antwort danach wurde aber
+       ganz verworfen, und damit blieb `expertenVorgabe` auf „aus":
+       Ohne gesetzten `sessionStorage` fehlten alle Expertenobjekte im
+       Baum, ohne dass irgendwo stand, warum. Die Sprache umzustellen,
+       nachdem schon beschriftet ist, waere ein Sprung vor den Augen —
+       die bleibt beim Naechstbesten; der Expertenmodus wird nachgezogen
+       und der Baum neu gezeichnet, wenn er sich unterscheidet. */
+    var expNeu = !!(!err && obj && obj.common && obj.common.expertMode);
     var l = (!err && obj && obj.common && obj.common.language) || vorgabe;
+    if (beantwortet) {
+      if (expNeu !== expertenVorgabe) {
+        expertenVorgabe = expNeu;
+        if (typeof spaeterExperte === 'function') { spaeterExperte(); }
+      }
+      return;
+    }
+    beantwortet = true;
+    expertenVorgabe = expNeu;
     weiter(l);
   });
   setTimeout(function () {
@@ -67,6 +83,12 @@ export function ladeSprache(fertig) {
   }, 2500);
 }
 
+/* Wer den Baum neu zeichnet, wenn der Expertenmodus spaet eintrifft.
+   Von aussen gesetzt, damit `sprache.js` nichts ueber den Baum wissen
+   muss. */
+var spaeterExperte = null;
+export function beiSpaetemExperten(fn) { spaeterExperte = fn; }
+
 /* Beschriftungen im festen HTML nachziehen. */
 export function beschrifteHtml() {
   document.title = tr('app.title');
@@ -133,8 +155,30 @@ export function sprachtext(v) {
   return String(v);
 }
 
+/* Frueher stand hier `v.de || v.en` — die eingestellte Sprache kam
+   nicht vor. Auf einem englischen Admin standen mehrsprachig benannte
+   Objekte, Raeume und Funktionen deshalb deutsch da, waehrend
+   `sprachtext` eine Zeile darueber es richtig machte. Zwei Leser fuer
+   dieselbe Frage sind einer zu viel. */
 export function txt(v) {
-  if (v === undefined || v === null) { return ''; }
-  if (typeof v === 'object') { return v.de || v.en || ''; }
-  return String(v);
+  return sprachtext(v);
+}
+
+/* Alle Sprachfassungen eines Namens, klein geschrieben.
+
+   Fuer den Abgleich mit Bestandsnamen: In der Anlage steht „Light",
+   von Hand getippt; die Vorlage sagt „Licht". Wer nur eine Fassung
+   vergleicht — und die auch noch nach Gross- und Kleinschreibung —,
+   legt eine zweite Funktion `enum.functions.light` neben die
+   vorhandene. */
+export function alleTexte(v) {
+  if (v === undefined || v === null) { return []; }
+  var raus = [];
+  var dazu = function (x) {
+    var t = String(x || '').trim().toLowerCase();
+    if (t && raus.indexOf(t) === -1) { raus.push(t); }
+  };
+  if (typeof v === 'object') { Object.keys(v).forEach(function (k) { dazu(v[k]); }); }
+  else { dazu(v); }
+  return raus;
 }

package/admin/js/start.js

@@ -4,8 +4,9 @@
 import { zeichneErgebnis } from './ergebnis.js';
 import { socket } from './verbindung.js';
 import { $ } from './basis.js';
-import { tr, ladeSprache, beschrifteHtml } from './sprache.js';
-import { ladeObjekte } from './objekte.js';
+import { tr, ladeSprache, beschrifteHtml, beiSpaetemExperten } from './sprache.js';
+import { ladeObjekte, abosErneuern } from './objekte.js';
+import { zeichneBaum } from './baum.js';
 import { ladeBefehlswissen } from './mqtt.js';
 import { ladeVorlagen, setzeMeta } from './vorlagen.js';
 import { ladeMusterNamen } from './musternamen.js';
@@ -13,6 +14,11 @@ import { S } from './zustand.js';
 
 
 /* ================== Verbindung ================== */
+/* Kommt die Expertenvorgabe erst nach dem Zeitablauf, muss der Baum
+   noch einmal gezeichnet werden — sonst fehlen die Expertenobjekte, bis
+   jemand den Reiter neu laedt. */
+beiSpaetemExperten(function () { zeichneBaum(); });
+
 socket.on('connect', function () {
   var c = $('#conn');
   c.className = 'conn on';
@@ -32,6 +38,30 @@ socket.on('connect', function () {
   });
   });
 });
+/* `connect` feuert genau einmal pro Seitenleben.
+
+   Der Reiter laedt nicht socket.io, sondern den WebSocket-Shim des
+   Admin (`ioBroker WebSockets`, bluefox). Dort steht woertlich:
+   `this.wasConnected ? this.reconnectHandlers.forEach(…)
+   : (this.connectHandlers.forEach(…), this.wasConnected = true)`.
+   Nach dem ersten Mal kommt also nur noch `reconnect` — und das hoerte
+   niemand. Folge jedes Aussetzers (Admin-Neustart, Netzwerkhaenger,
+   Standby): der Punkt blieb auf „getrennt" stehen, obwohl die
+   Verbindung wieder stand, und weder `objectChange` noch `stateChange`
+   kamen jemals wieder an (gemessen 09.09.2026 mit einem echten
+   `socket.close()`).
+
+   Neu geladen wird der ganze Bestand, nicht nur nachabonniert:
+   waehrend der Trennung kann sich alles geaendert haben, und ohne Abo
+   hat es niemand mitbekommen. Sprache, Geraetewissen und Vorlagen
+   bleiben, wie sie sind — die aendern sich nicht im Betrieb. */
+socket.on('reconnect', function () {
+  var c = $('#conn');
+  c.className = 'conn on';
+  c.textContent = tr('app.connected');
+  abosErneuern();
+  ladeObjekte();
+});
 socket.on('disconnect', function () {
   var c = $('#conn');
   c.className = 'conn off';

package/admin/js/vorlagen.js

@@ -112,6 +112,15 @@ export function ladeVorlagen(fertig) {
        sie behauptet dann nicht, es gaebe keine eigenen Vorlagen. */
     setTimeout(function () { schluss([], true); }, 6000);
     socket.emit('getObject', INSTANZ_ID, function (err, o) {
+      /* Denselben Weg wie der Timeout eine Zeile darueber: ein Fehler
+         heisst nicht „keine eigenen Vorlagen".
+
+         `err` wurde vorher nicht einmal angesehen. Zwei Folgen: in der
+         Kopfzeile fehlte der Warnchip, und `freierSchluessel` hielt
+         vergebene Kennungen fuer frei — beim naechsten Speichern haette
+         `aendereVorlagen` eine vorhandene Vorlage mit Version 1
+         ersetzt. */
+      if (err) { return schluss([], true); }
       schluss((o && o.native && o.native.vorlagen) || []);
     });
   }
@@ -295,6 +304,47 @@ function punktErfuellt(kanal, pfad) {
 }
 
 /* Passt die Vorlage auf diesen Kanal? Liefert null oder eine Bewertung. */
+/* Der Namenshinweis als Ausdruck — und der wirft nicht.
+
+   Der Text kommt frei aus dem Vorlagenblatt und aus dem
+   Speichern-Dialog; keins der beiden Felder prueft ihn. Ein `Lampe (Bad`
+   liess `pruefeVorlage` bei JEDER Geraeteauswahl werfen, kein Aufrufer
+   fing das, und die rechte Seite blieb leer — zu reparieren nur ueber
+   die Instanzkonfiguration von Hand (gemessen 09.09.2026). `rolleTrifft`
+   in `erkennung.js` faengt denselben Fall laengst ab; hier fehlte es.
+
+   Ein unbrauchbarer Ausdruck heisst „trifft nicht": der Hinweis ist nur
+   ein Bonus in der Bewertung, keine Bedingung. Die Vorlage bleibt damit
+   brauchbar, statt das ganze Werkzeug mitzureissen. */
+export function hinweisTrifft(hinweis, name) {
+  if (!hinweisTaugt(hinweis)) { return false; }
+  try { return new RegExp(hinweis, 'i').test(name); }
+  catch { return false; }
+}
+
+/* Verschachtelte Wiederholungen — `(a+)+`, `(a*)*`, `(a+){2,}`.
+
+   Die klassische Form, an der eine RegExp-Maschine in die Knie geht:
+   `(a+)+$` gegen neunundzwanzig "a" brauchte hier gemessene 3196 ms,
+   und der ganze Reiter stand solange (09.09.2026). Ein try/catch faengt
+   das nicht — die Syntax ist ja in Ordnung, es dauert nur ewig.
+
+   Das ist eine Heuristik, kein Beweis: Sie deckt die Form ab, die man
+   sich versehentlich baut, nicht jeden denkbaren Fall. Fuer einen
+   Namenshinweis reicht das — er soll ein Wort im Geraetenamen finden,
+   nicht eine Sprache parsen. */
+function verschachtelt(hinweis) {
+  return /\([^()]*[+*][^()]*\)\s*([+*]|\{\s*[0-9]+\s*,)/.test(String(hinweis));
+}
+
+/* Taugt der Text als Ausdruck? Fuer die Felder, die ihn aufnehmen. */
+export function hinweisTaugt(hinweis) {
+  if (!hinweis) { return true; }
+  if (verschachtelt(hinweis)) { return false; }
+  try { new RegExp(hinweis, 'i'); return true; }
+  catch { return false; }
+}
+
 export function pruefeVorlage(v, kanal, instanz) {
   var erk = v.erkennung || {};
   var gruende = [];
@@ -367,7 +417,7 @@ export function pruefeVorlage(v, kanal, instanz) {
   var belege = (erk.erforderlich || []).length *
                (v.mehrfach ? Math.max(1, ausgaenge.length) : 1) +
                Object.keys(erk.inhalt || {}).length;
-  var namenstreffer = !!(erk.namenshinweis && new RegExp(erk.namenshinweis, 'i').test(name));
+  var namenstreffer = !!(erk.namenshinweis && hinweisTrifft(erk.namenshinweis, name));
   if (namenstreffer) { gruende.push(tr('tpl.nameHint', sprachtext(v.name))); }
   var eigen = v._quelle === 'benutzer';
   var punkte = belege * 1000000 +
@@ -469,6 +519,34 @@ export function wendeAn(v, kanal, gruende, instanz, auchOhneTreffer) {
       break;
     }
 
+    /* Ein Tastendruck hat keinen Zustand zum Lesen.
+
+       `STOP` am Rollladen traegt nur `schreiben` — genau so steht es in
+       der Vorlage, mit Begruendung. Diesen Fall kannte das Anwenden
+       nicht: Ohne `lesen` fiel der Punkt mit „STOP: undefined fehlt"
+       heraus, und KEIN EINZIGER Rollladen-Alias bekam je einen STOP
+       (gefunden 09.09.2026). Der Platz im Muster verlangt auch nichts
+       weiter als `write: true`. */
+    var nurSchreiben = !z.lesen && !!z.schreiben;
+    if (nurSchreiben && !quelle) {
+      var ziel0 = schreibZiel(z, kanal, auf);
+      if (!ziel0) {
+        e.uebersprungen.push(tr('tpl.skippedSource', z.name, auf(z.schreiben)));
+        return;
+      }
+      e.states.push({
+        n: z.name, on: !z.vorgabeAus, role: z.rolle || '', typ: z.typ || '',
+        unit: z.einheit || '', wr: true,
+        srcR: '', srcW: ziel0,
+        f: '', fw: z.schreibformel ? auf(z.schreibformel) : '',
+        caption: z.beschriftung || '',
+        dec: z.nachkommastellen === undefined ? undefined : String(z.nachkommastellen),
+        states: z.werteliste || undefined,
+        manuell: false, ausVorlage: z.name, hinweis: z.hinweis || '', wege: []
+      });
+      return;
+    }
+
     if (!quelle) {
       /* Beide Wege nennen, nicht nur den letzten — sonst sucht man an der
          einen Stelle und die Vorlage hatte an zwei geschaut. */
@@ -481,7 +559,15 @@ export function wendeAn(v, kanal, gruende, instanz, auchOhneTreffer) {
     /* Auch in der Formel steht der Platzhalter — ohne Ersetzung suchte
        der Alias nach einem Feld namens POWER%N%. */
     var formel = leseformel ? auf(leseformel) : '';
-    if (feld) {
+    /* Wer eine Formel hinschreibt, bekommt sie auch.
+
+       `tasmota-rgb` fuehrt an FADE beides: `feld` UND `leseformel`. Die
+       Formel wurde verworfen und aus dem Feld eine neue gebaut — bei
+       FADE faellt es nicht auf, weil der Zieltyp die Umwandlung
+       nachholt, an der naechsten Zeile mit eigener Rechnung aber schon
+       (gefunden 09.09.2026). Das Feld bleibt der bequeme Weg; die
+       ausdrueckliche Angabe schlaegt ihn. */
+    if (feld && !formel) {
       feld = auf(feld);
       /* Mit Fragezeichen-Zugriff: `tele.SENSOR` ist ein Sammeltopf, und
          nicht jede Nachricht darin fuehrt jedes Feld. Ohne Schutz wirft
@@ -563,8 +649,10 @@ export function vorschlag(kanal, vorlagenId, instanz) {
     e.erzwungen = true;
     e.grund = e.grund.concat(gewaehlt.fehler.map(function (f) { return tr('tpl.wouldNeed', f); }));
   }
-  e.andere = treffer.filter(function (t) { return t.vorlage.id !== gewaehlt.vorlage.id; })
-                    .map(function (t) { return t.vorlage; });
+  /* Hier stand `e.andere` — die Liste der unterlegenen Vorlagen. Sie
+     wurde bei jedem Vorschlag gebaut und von niemandem gelesen
+     (gefunden 09.09.2026). Was der Nutzer wirklich braucht, steht im
+     Musterwahl-Feld und im Vorlagenblatt. */
   if (vorlagenId) { e.vonHandGewaehlt = true; }
   return merkeHakenVorgabe(e);
 }