iobroker.alias-workbench 0.11.0 → 0.12.0

package/admin/js/baum.js

@@ -8,9 +8,10 @@ import { S } from './zustand.js';
 import { $, el } from './basis.js';
 import { tr, txt, expertenVorgabe } from './sprache.js';
 import './enums.js';
-import { mitNachfrage, aboLoesen } from './entwurf.js';
+import { mitNachfrage, aboLoesen, zweigUmschalten, zweigPfade, waehle } from './entwurf.js';
 import { zeichneErgebnis } from './ergebnis.js';
 import { zeichneVorlagenListe } from './vorlagenblatt.js';
+import { zeigeMenue } from './attrappe.js';
 
 var KLAPP_SCHLUESSEL = 'alias-workbench.baum';
 
@@ -205,6 +206,17 @@ export function zeichneBaum() {
   }
 }
 
+/* Warum ein Strg-Klick nicht angekommen ist.
+
+   „schon drin" und „der letzte" brauchen keine Worte - da passiert
+   sichtbar nichts, und das versteht sich. „Aus einer anderen Instanz"
+   braucht sie: sonst klickt jemand dreimal und haelt es fuer kaputt. */
+function meldeZweig(grund) {
+  if (grund !== 'fremd') { return; }
+  S.zweigMeldung = tr('tree.branchForeign');
+  zeichneErgebnis();
+}
+
 /* Waehlbar ist alles, unter dem irgendwo Zustaende liegen — nicht nur
    direkt darunter. MQTT legt fuer Zwischenebenen gar keine Objekte an:
    unter …SmartHome.Karbonator existieren nur tele.LWT, tele.SENSOR und
@@ -391,8 +403,14 @@ function renderKinder(knoten, filter, tiefe) {
 
     var li = el('li');
     var waehlbar = istWaehlbar(k);
+    /* Bei einer Mehrfachauswahl ist JEDER gewaehlte Zweig markiert, und
+       der gemeinsame Elternknoten schwaecher - sonst sieht man nicht,
+       worauf der Entwurf steht. Denselben Mangel hatte das
+       Attrappen-Menue (Ricardo, 12.10.2026). */
+    var gewaehlt = zweigPfade().indexOf(k.id) !== -1;
+    var istEltern = !!(S.zweige && S.zweige.length) && k.id === S.current;
     var d = el('div', 'node' + (waehlbar ? ' pick' : ' grp') + (leer ? ' leer' : '') +
-      (k.id === S.current ? ' sel' : ''));
+      (gewaehlt ? ' sel' : '') + (istEltern ? ' selEltern' : ''));
 
     var hatKinder = kinderPassen;
     var auf = aufJetzt;
@@ -439,6 +457,11 @@ function renderKinder(knoten, filter, tiefe) {
       d.appendChild(el('span', 'cnt', k._zust + ''));
     }
 
+    /* Rechtsklick auf JEDE Zeile, nicht nur auf waehlbare: ausgeben
+       laesst sich auch ein Geraet oder ein Ordner, und gerade der ist
+       beim Nachbauen der interessante Knoten. */
+    d.addEventListener('contextmenu', function (e) { zeigeMenue(e, k.id, d); });
+
     if (waehlbar) {
       d.tabIndex = 0;
       d.setAttribute('role', 'button');
@@ -452,10 +475,34 @@ function renderKinder(knoten, filter, tiefe) {
          dazu, und die stehen nicht in den Zeilen. Geschrieben wird
          dadurch nichts — es geht nur darum, dass niemand etwas verliert,
          ohne gefragt zu werden. */
-      var go = function () { mitNachfrage(k.id); };
-      d.addEventListener('click', go);
+      /* Ein gewoehnlicher Klick waehlt EINEN Knoten - auch dann, wenn es
+         derselbe ist, auf dem gerade eine Mehrfachauswahl steht. Wer den
+         Elternknoten anklickt, will ihn ganz. */
+      var go = function () {
+        mitNachfrage(k.id, function () { S.zweige = null; waehle(k.id); });
+      };
+      /* Strg-Klick nimmt einen Zweig dazu oder heraus, statt die Auswahl
+         zu ersetzen. Strg und nicht Umschalt: Umschalt heisst ueberall
+         „Bereich von…bis", gewollt sind einzelne Zweige. Auf dem Mac
+         dieselbe Taste wie sonst dort (Cmd).
+
+         Wer keine Tastatur hat oder nicht weiss, dass es das gibt,
+         findet dasselbe im Rechtsklickmenue. */
+      var dazu = function () {
+        mitNachfrage(k.id, function () {
+          var grund = zweigUmschalten(k.id);
+          if (grund) { meldeZweig(grund); }
+        });
+      };
+      d.addEventListener('click', function (e) {
+        if (e.ctrlKey || e.metaKey) { e.preventDefault(); dazu(); return; }
+        go();
+      });
       d.addEventListener('keydown', function (e) {
-        if (e.key === 'Enter' || e.key === ' ') { e.preventDefault(); go(); }
+        if (e.key === 'Enter' || e.key === ' ') {
+          e.preventDefault();
+          if (e.ctrlKey || e.metaKey) { dazu(); } else { go(); }
+        }
       });
     }
     li.appendChild(d);

package/admin/js/entwurf.js

@@ -8,7 +8,7 @@ import { $ } from './basis.js';
 import { txt, tr } from './sprache.js';
 import './enums.js';
 import { zusatzName, setzeModus, zeichneBaum, merkeKlappstand } from './baum.js';
-import { kindZustaende, geraetePunkte, aliasQuellen, holeWerte,
+import { kindZustaende, geraetePunkte, aliasQuellen, holeWerte, istZerlegt,
   mitVorspann, schreibQuelle, zeileAusAlias, statesText, statesGleich, istTaster as istTasterObjekt
 } from './werte.js';
 import { erkenneEntwurf } from './erkennung.js';
@@ -77,10 +77,56 @@ export function baueEntwurf(kanal) {
      relativer Name kommt von dort. Sonst hiesse die Zeile
      `tele_Weihnachten_aussen_STATE` statt `tele_STATE`, und derselbe
      Tasmota ergaebe je nach FullTopic einen anderen Alias. */
-  geraetePunkte(kanal).forEach(function (p) {
+  var punkte = geraetePunkte(kanal);
+  /* Mehrere Zweige als ein Geraet: nur die gewaehlten. Gefiltert wird
+     NACH `geraetePunkte`, nicht davor - dessen Ergebnis liegt je Knoten
+     im Zwischenspeicher, und die Auswahl ist fluechtig. */
+  var mehrzweig = false;
+  if (S.zweige && S.zweige.length && kanal === S.current) {
+    mehrzweig = true;
+    punkte = punkte.filter(function (p) {
+      return S.zweige.some(function (z) { return p.rel === z || p.rel.indexOf(z + '.') === 0; });
+    });
+  }
+  /* Kurze Namen, wo sie eindeutig sind.
+
+     Aus `OnOffPlugInUnit-1.SET` soll `SET` werden - sonst hiesse der
+     Alias-Punkt `OnOffPlugInUnit-1_SET`, und die Zeile traegt den Namen
+     eines Endpoints, den ausser dem Adapter niemand kennt. Gekuerzt wird
+     nur, wenn das letzte Glied unter den GEWAEHLTEN Zweigen genau einmal
+     vorkommt; sonst bliebe nicht unterscheidbar, welcher Zweig gemeint
+     ist.
+
+     Nicht bei einem zerlegten Geraet (Tasmota): dort ist der Zweig
+     bedeutungstragend. `cmnd.POWER` und `stat.POWER` kuerzten sich
+     ohnehin nicht, weil `POWER` zweimal vorkommt - aber `tele.SENSOR`
+     waere eindeutig und wuerde zu `SENSOR`. Das haette jeden
+     bestehenden MQTT-Alias gebrochen.
+
+     Dasselbe gilt, wenn jemand die Sparten eines Tasmota ausdruecklich
+     zusammenklickt (`…Steckdose.stat` + `…Steckdose.tele`). Dort heisst
+     der Zweig `cmnd`, `stat` oder `tele`, und die Vorlagen adressieren
+     genau so (`stat.POWER`). Gekuerzt faende keine von ihnen mehr ihr
+     Ziel. */
+  var kurz = {};
+  var sparte = (S.zweige || []).some(function (zg) {
+    return SPARTEN.indexOf(zg.split('.').pop()) !== -1;
+  });
+  if (mehrzweig && !sparte && !istZerlegt(kanal)) {
+    var zaehler = {};
+    punkte.forEach(function (p) {
+      var k = p.rel.split('.').pop();
+      zaehler[k] = (zaehler[k] || 0) + 1;
+    });
+    punkte.forEach(function (p) {
+      var k = p.rel.split('.').pop();
+      if (zaehler[k] === 1 && k !== p.rel) { kurz[p.rel] = k; }
+    });
+  }
+  punkte.forEach(function (p) {
     var id = p.id;
     var o = S.objects[id], c = o.common || {}, a = c.alias || {}, q = aliasQuellen(o);
-    var kurzName = p.rel;
+    var kurzName = kurz[p.rel] || p.rel;
     /* Ein Knopfdruck hat keinen Zustand — sonst hat auch ein
        nur-schreibender Punkt einen.
 
@@ -980,7 +1026,85 @@ export function aboErgaenzen(quellen) {
   zeigeAbozahl();
 }
 
-export function waehle(id, fertig) {
+/* Die gewaehlten Zweige als volle Kennungen - eine Liste, auch wenn es
+   nur einer ist. */
+export function zweigPfade() {
+  if (!S.current) { return []; }
+  if (!S.zweige || !S.zweige.length) { return [S.current]; }
+  return S.zweige.map(function (z) { return S.current + '.' + z; });
+}
+
+/* Der laengste gemeinsame Elternknoten mehrerer Kennungen - auf
+   Punktgrenzen, nicht auf Zeichen. */
+function gemeinsamerEltern(ids) {
+  var teile = ids[0].split('.');
+  for (var i = 1; i < ids.length; i++) {
+    var t2 = ids[i].split('.');
+    var n = 0;
+    while (n < teile.length && n < t2.length && teile[n] === t2[n]) { n++; }
+    teile = teile.slice(0, n);
+  }
+  return teile.join('.');
+}
+
+/* Einen Zweig dazunehmen oder herausnehmen.
+
+   Gedacht fuer Geraete, die ueber Geschwisterzweige verteilt liegen
+   (Matter, siehe `S.zweige`). Der gemeinsame Elternknoten wird zur
+   Auswahl, die angeklickten Zweige zu `S.zweige`.
+
+   Gibt einen Grund zurueck, wenn es nicht geht - dann hat sich nichts
+   geaendert. */
+export function zweigUmschalten(id) {
+  if (!S.current) { return 'leer'; }
+  var pfade = zweigPfade();
+  var drin = pfade.indexOf(id);
+  if (drin !== -1) {
+    /* Der letzte laesst sich nicht abwaehlen - sonst stuende rechts
+       nichts mehr, und der Klick saehe aus wie ein Fehler. */
+    if (pfade.length < 2) { return 'letzter'; }
+    pfade.splice(drin, 1);
+  } else {
+    /* Ein Zweig, der einen anderen enthaelt (oder in ihm liegt), ist
+       kein zweiter Zweig - sonst zaehlten dieselben Punkte doppelt. */
+    var verschachtelt = pfade.some(function (p) {
+      return p === id || id.indexOf(p + '.') === 0 || p.indexOf(id + '.') === 0;
+    });
+    if (verschachtelt) { return 'verschachtelt'; }
+    pfade.push(id);
+  }
+  var eltern = gemeinsamerEltern(pfade);
+  /* Nie ueber die Instanz hinaus. Zwei Zweige aus verschiedenen
+     Adaptern haetten gar keinen gemeinsamen Elternknoten, und zwei
+     Instanzen desselben Adapters nur den Adapternamen - in beiden
+     Faellen stuende die Werkbank auf einem Knoten, der kein Ort ist.
+     Ein Geraet liegt in einer Instanz; das ist keine kuenstliche
+     Schranke, sondern die Lage. */
+  if (!eltern || eltern.split('.').length < 2) { return 'fremd'; }
+  var zweige = pfade.map(function (p) { return p.slice(eltern.length + 1); })
+    .filter(function (z) { return z; });
+  /* Steht ein gewaehlter Pfad selbst auf dem Elternknoten, ist „alles"
+     gemeint - dann ist es wieder eine gewoehnliche Auswahl. */
+  S.zweige = (zweige.length === pfade.length && zweige.length > 1) ? zweige.sort() : null;
+  waehle(eltern, null, true);
+  return '';
+}
+
+export function waehle(id, fertig, zweigeBehalten) {
+  /* Ein ANDERER Knoten hebt die Mehrfachauswahl auf, derselbe nicht.
+
+     `waehle(S.current)` heisst an drei Stellen „bau den Entwurf neu" -
+     nach dem Nachladen der Objekte (`objekte.js`), nach einer Aenderung
+     am Bestand (`ergebnis.js`) und nach dem Schreiben (`schreiben.js`).
+     Eine Regel, die hier bei JEDEM Aufruf aufraeumt, loescht die
+     Auswahl beim naechsten Objektereignis aus dem Admin - gemessen
+     13.10.2026 in AA3, wo ein neu angelegter Datenpunkt sie mitnahm.
+
+     Dass ein gewoehnlicher KLICK auf den Elternknoten „alles" bedeutet,
+     entscheidet der Klick selbst (`baum.js`), nicht diese Funktion.
+     `zweigeBehalten` setzt nur `zweigUmschalten`, das den Knoten
+     absichtlich wechselt. */
+  if (!zweigeBehalten && id !== S.current) { S.zweige = null; }
   /* Wer links etwas anderes anklickt, will es rechts sehen - auch wenn
      der Fokus noch in einem Feld der rechten Seite steht. `tipptGerade`
      haelt das Neuzeichnen zurueck, damit ein eintreffender Messwert
@@ -1042,8 +1166,11 @@ export function waehle(id, fertig) {
      Zeilen mit neuen Quellen dazukommen. Eine Liste, damit beim
      naechsten Wechsel `aboLoesen` alles abmeldet. */
   aboLoesen();
-  S.abo = [id + '.*'];
-  socket.emit('subscribe', id + '.*');
+  /* Bei mehreren Zweigen nur diese, nicht den ganzen Elternknoten. Der
+     traegt oft mehr, als zum Geraet gehoert - bei Matter den Kanal
+     `info` mit der Verbindungsmeldung, anderswo gleich mehrere Geraete. */
+  S.abo = zweigPfade().map(function (p) { return p + '.*'; });
+  S.abo.forEach(function (m) { socket.emit('subscribe', m); });
   if (id.indexOf('alias.') === 0) {
     var ausAlias = [];
     kindZustaende(id).forEach(function (kid) {

package/admin/js/ergebnis.js

@@ -37,7 +37,9 @@ import {
   bestandVorrang,
   kanalGruppen,
   aufteilBehaelter,
-  rohEntwurf
+  rohEntwurf,
+  zweigPfade,
+  zweigUmschalten
 } from './entwurf.js';
 import { setzeEnums, setzeZiel, unterschiede } from './zuordnung.js';
 import './detail.js';
@@ -55,7 +57,7 @@ import {
 } from './schreiben.js';
 
 import { mqttKarte, mqttSchreiben } from './mqtt.js';
-import { kindZustaende, direkteZustaende } from './werte.js';
+import { kindZustaende, direkteZustaende, mitVorspann } from './werte.js';
 import './aufzaehlungen.js';
 import { erkenneEntwurf } from './erkennung.js';
 import { zusatzName } from './baum.js';
@@ -308,6 +310,57 @@ var warumAuf = false;
   /* Der Kopf: was links angeklickt wurde - Name, Kennung, Bestand
      und der Sprungknopf zum Gegenstueck. Nicht, was daraus werden
      soll: das sagt die Zielzeile darunter. */
+  /* Geschwisterzweige mit eigenen Datenpunkten, die noch nicht zur
+     Auswahl gehoeren.
+
+     Gemeint sind Geraete, die ein Adapter auf mehrere Zweige verteilt -
+     Matter legt den Schalter in `OnOffPlugInUnit-1` und die Messwerte in
+     `ElectricalSensor-2`. Angeboten wird das nur, nie ausgefuehrt.
+
+     Nicht angeboten wird es an einem Alias (dort gibt es nichts
+     zusammenzufassen) und nicht unter einer Instanzwurzel, wo die
+     „Nachbarn" schlicht alle anderen Geraete waeren. */
+  function nachbarZweige() {
+    if (!S.current || S.current.indexOf('alias.') === 0) { return []; }
+    var pfade = zweigPfade();
+    var eltern = (S.zweige && S.zweige.length)
+      ? S.current
+      : S.current.slice(0, S.current.lastIndexOf('.'));
+    if (!eltern || eltern.split('.').length < 3) { return []; }
+    var vor = eltern + '.';
+    var kinder = {};
+    mitVorspann(vor).forEach(function (id) {
+      var rest = id.slice(vor.length);
+      var erst = rest.split('.')[0];
+      if (!erst) { return; }
+      if (S.objects[id] && S.objects[id].type === 'state') { kinder[vor + erst] = 1; }
+    });
+    return Object.keys(kinder).filter(function (k) {
+      return pfade.indexOf(k) === -1 &&
+        !pfade.some(function (p) { return k.indexOf(p + '.') === 0 || p.indexOf(k + '.') === 0; });
+    }).sort();
+  }
+
+  /* Warum das ein Geraet sein koennte - wo es belegbar ist.
+
+     Matter schreibt an jeden Endpoint dieselbe `nodeId` und dieselbe
+     `statusStates.onlineId` (gemessen an matter.0.controller.2,
+     13.10.2026). Wo das zutrifft, ist es keine Vermutung. Wo nicht,
+     bleibt es ein nuechternes Angebot. */
+  function nachbarnGrund(nachbarn) {
+    var eigen = S.objects[zweigPfade()[0]] || {};
+    var kennung = function (o) {
+      var st = ((o.common || {}).statusStates || {}).onlineId || '';
+      var nid = (o.native || {}).nodeId;
+      return st + '|' + (nid === undefined ? '' : nid);
+    };
+    var meins = kennung(eigen);
+    var gleich = meins !== '|' && nachbarn.every(function (n) {
+      return kennung(S.objects[n] || {}) === meins;
+    });
+    return gleich ? tr('result.addNeighboursSame') : tr('result.addNeighboursHint');
+  }
+
   function baueKopf() {
     var obj = S.objects[S.current] || {};
     var alleZust = kindZustaende(S.current);
@@ -322,6 +375,18 @@ var warumAuf = false;
        oben steht, nicht unter den Bestandszaehler. */
     var namensZeile = el('div', 'namzeile');
     namensZeile.appendChild(el('div', 'id', kopfName || S.current.split('.').pop()));
+    /* Liegt das Geraet auf mehrere Geschwisterzweige verteilt, steht der
+       Weg dorthin hier - sichtbar. Strg-Klick im Baum tut dasselbe, aber
+       den findet nur, wer schon weiss, dass es ihn gibt. */
+    var nachbarn = nachbarZweige();
+    if (nachbarn.length) {
+      var nk = el('button', 'btn klein', tr('result.addNeighbours', nachbarn.length));
+      nk.title = nachbarnGrund(nachbarn);
+      nk.addEventListener('click', function () {
+        nachbarn.forEach(function (n) { zweigUmschalten(n); });
+      });
+      namensZeile.appendChild(nk);
+    }
     links.appendChild(namensZeile);
     links.appendChild(el('div', 'pfad', S.current));
 
@@ -1050,6 +1115,16 @@ var warumAuf = false;
     var sg0 = $('#sperrgrund');
     if (sg0) { sg0.hidden = true; sg0.textContent = ''; }
     if (S.baumModus === 'vorlagen') { return zeichneVorlagenBlatt(host); }
+    /* Eine Meldung aus dem Baum - einmal zeigen, dann weg. Sie steht
+       ganz oben, weil sie auf einen Klick antwortet, der sonst wirkungslos
+       aussieht. */
+    if (S.zweigMeldung) {
+      var zm = el('div', 'aside w');
+      zm.style.borderLeftColor = 'var(--warn)';
+      zm.textContent = S.zweigMeldung;
+      host.appendChild(zm);
+      S.zweigMeldung = '';
+    }
     var bck = $('#btn-checks');
     if (bck) { bck.disabled = false; }
     if (!S.current || !S.entwurf) { return zeichneLeer(host); }