iobroker.alias-workbench 0.9.11 → 0.10.0

package/admin/js/werte.js

@@ -42,7 +42,7 @@ export function jsonVon(id) {
 }
 
 export function feldWert(obj, pfad) {
-  var t = pfad.split('.');
+  var t = pfadTeile(pfad);
   var x = obj;
   for (var i = 0; i < t.length; i++) {
     if (x === null || x === undefined || typeof x !== 'object') { return undefined; }
@@ -171,7 +171,11 @@ export function zeileAusAlias(o, zeilenname) {
        aber als Lesequelle gilt sie nicht: sonst zeigte „Alias bearbeiten"
        eine Quelle, die „Alias anlegen" nie eingetragen hat, und beim
        naechsten Aktualisieren kippte `read` still auf `true` zurueck. */
-    srcR: (c.read === false && q.einfach) ? '' : (q.read || ''),
+    /* Seit 19.09.2026 auch beim Taster: `read: false` am Alias haengt an
+       der Rolle, nicht an einer fehlenden Lesequelle (`knopfZeile`). Ein
+       alter Taster-Alias mit einfacher `alias.id` liest also aus seinem
+       Schreibziel - genau das, was ioBroker mit ihm ohnehin tut. */
+    srcR: q.read || '',
     srcW: schreibQuelle(o),
     f: (typeof a.read === 'string') ? a.read : '',
     fw: (typeof a.write === 'string') ? a.write : '',
@@ -285,7 +289,7 @@ export function auswerten(formel, roh) {
   var gedauert = performance.now() - t0;
   if (gedauert > GEDULD_MS) {
     formelGesperrt[formel] = Math.round(gedauert);
-    console.warn('[alias-workbench] Formel gesperrt nach ' + Math.round(gedauert) + ' ms: ' + formel);
+    console.warn('[alias-workbench] Formula blocked after ' + Math.round(gedauert) + ' ms: ' + formel);
     return { ok: false, txt: tr('detail.formulaTooSlow', Math.round(gedauert)), fehler: true };
   }
   if (sch !== null) {
@@ -375,6 +379,49 @@ var FELDTEIL = "\\??\\.(?:[A-Za-z_$][\\w$]*|\\[(?:'(?:[^'\\\\]|\\\\.)*'|\"(?:[^\
 var FELDPFAD = new RegExp('^JSON\\.parse\\(val\\)((?:' + FELDTEIL + ')+)(?:\\s*\\?\\?\\s*null)?$');
 var FELDSTUECK = new RegExp(FELDTEIL, 'g');
 
+/* Der Feldpfad als Text und zurueck (X12, 19.09.2026).
+
+   Gewoehnlich sind die Stuecke durch Punkte getrennt: `ENERGY.Power`,
+   `service.storage./dev/shm.free`. Das bleibt zeichengleich - so stehen
+   die Pfade in gespeicherten Vorlagen, und die sollen weiter gelten.
+   Nur ein Schluessel, der SELBST einen Punkt enthaelt, steht in Klammern
+   ohne Punkt davor: `cpu_usages['frigate.full_system'].cpu`. Vorher
+   wurde er an jedem Punkt zerteilt, die Formel suchte
+   `?.frigate?.full_system` und ergab null. Frigate hat so einen
+   Schluessel in `stats`. Ein Stueck, das mit `[` anfaengt, kommt aus
+   demselben Grund in Klammern. */
+export function pfadAus(teile) {
+  var raus = '';
+  teile.forEach(function (t, n) {
+    t = String(t);
+    if (t.indexOf('.') > -1 || t.charAt(0) === '[') {
+      raus += "['" + t.replace(/\\/g, '\\\\').replace(/'/g, "\\'") + "']";
+    } else {
+      raus += (n ? '.' : '') + t;
+    }
+  });
+  return raus;
+}
+
+export function pfadTeile(pfad) {
+  var s = String(pfad || ''), teile = [], i = 0;
+  while (i < s.length) {
+    if (s.charAt(i) === '.') { i++; continue; }
+    if (s.slice(i, i + 2) === "['") {
+      var j = i + 2, t = '';
+      while (j < s.length && !(s.charAt(j) === "'" && s.charAt(j + 1) === ']')) {
+        if (s.charAt(j) === '\\' && j + 1 < s.length) { j++; }
+        t += s.charAt(j); j++;
+      }
+      teile.push(t); i = j + 2; continue;
+    }
+    var k = i;
+    while (k < s.length && s.charAt(k) !== '.' && s.slice(k, k + 2) !== "['") { k++; }
+    teile.push(s.slice(i, k)); i = k;
+  }
+  return teile;
+}
+
 export function feldAusFormel(f) {
   var m = FELDPFAD.exec(f || '');
   if (!m) { return ''; }
@@ -386,21 +433,19 @@ export function feldAusFormel(f) {
     if (s.charAt(0) === '[') {
       /* Nur die Fluchtzeichen zurueckdrehen, die feldSegment setzt. */
       s = s.slice(2, -2).replace(/\\(.)/g, '$1');
-      /* Ein Punkt im Schluessel selbst laesst sich im Pfadformat von
-         `jsonFelder` nicht wieder auseinanderhalten — dann lieber
-         „eigene Formel" zeigen als einen Pfad, der nicht zurueckfuehrt. */
-      if (s.indexOf('.') > -1) { return ''; }
     }
     teile.push(s);
   }
-  return teile.join('.');
+  /* Ein Punkt im Schluessel selbst kommt seit X12 in Klammern zurueck
+     (`pfadAus`); vorher hiess das hier „eigene Formel". */
+  return pfadAus(teile);
 }
 
 /* Der abgesicherte Zugriff auf ein JSON-Feld. An einer Stelle, damit die
    Vorlagen-Abkuerzung und die Feldauswahl im Detail dasselbe bauen. */
 export function feldFormel(feld) {
   if (!feld) { return ''; }
-  return 'JSON.parse(val)' + String(feld).split('.').map(feldSegment).join('') + ' ?? null';
+  return 'JSON.parse(val)' + pfadTeile(feld).map(feldSegment).join('') + ' ?? null';
 }
 
 /* ---- Feldpfade: Ende ---- */
@@ -412,18 +457,49 @@ export function jsonFelder(id) {
   try { o = JSON.parse(st.val); } catch { return null; }
   if (!o || typeof o !== 'object') { return null; }
   var raus = [];
-  (function geh(x, pfad, tiefe) {
+  (function geh(x, weg, tiefe) {
     if (tiefe > 3) { return; }
     Object.keys(x).forEach(function (k) {
-      var p = pfad ? pfad + '.' + k : k;
-      if (x[k] && typeof x[k] === 'object' && !Array.isArray(x[k])) { geh(x[k], p, tiefe + 1); }
-      else { raus.push(p); }
+      var w = weg.concat([k]);
+      if (x[k] && typeof x[k] === 'object' && !Array.isArray(x[k])) { geh(x[k], w, tiefe + 1); }
+      else { raus.push(pfadAus(w)); }
     });
-  })(o, '', 0);
+  })(o, [], 0);
   return raus;
 }
 
 
+/* Ist das Objekt ein Taster - ein Punkt ohne Zustand?
+
+   `read: false` allein reicht nicht (siehe `zielKann`). Dazu muss er
+   schreibbar sein und sich als Tastendruck ausweisen: Homematic ueber
+   `native.TYPE: ACTION`, alle anderen ueber eine Rolle `button…`. Die
+   eine Stelle fuer diese Frage - der Entwurf fragt sie auch. */
+export function istTaster(o) {
+  var c = (o && o.common) || {};
+  var nat = (o && o.native) || {};
+  return c.read === false && !!c.write &&
+    (nat.TYPE === 'ACTION' || /^button/.test(String(c.role || '')));
+}
+
+/* Wird der Alias-Datenpunkt ein Knopf?
+
+   Die eine Regel fuer `common.read` am Alias (Ricardo, 19.09.2026): Rolle
+   `button…` UND ein Schreibziel -> Knopf, `read: false`. Alles andere
+   `read: true`. So steht es in der Rollenliste von ioBroker: „Buttons
+   (booleans, write-only) … common.write=true, common.read=false"; der
+   Tastensensor (`button.press`, `button.long` ohne Schreiben) liest.
+
+   Nicht aus der Quelle abgeleitet: deren `read` setzt jeder Adapter
+   anders. hm-rpc schreibt `read: false` an `BOOST_MODE`, einen Schalter,
+   der seinen Zustand meldet - uebernommen, zeichneten vis, Alexa und
+   matter den Boost als Knopf. Und nicht aus einer fehlenden Lesequelle:
+   gemessen am Testsystem liest ein Alias mit `read: false` trotzdem aus
+   seiner Lesequelle, jeder Druck kommt an. */
+export function knopfZeile(s) {
+  return !!(s && s.srcW && /^button/.test(String(s.role || '')));
+}
+
 /* ---- Was das Ziel kann ---------------------------------------------
 
    Die Werkbank schreibt auf fremde Punkte und liest aus fremden Punkten.
@@ -440,8 +516,15 @@ export function jsonFelder(id) {
                     Schreibvorgang trotzdem durch — gemessen —, der Adapter
                     dahinter reicht ihn aber nicht ans Geraet weiter.
                     Ein stiller Blindgaenger.
-     `meldetNichts` Die Lesequelle traegt `read: false`. Ein Tastendruck
-                    hat keinen Zustand; gelesen wird dort nie etwas.
+   Bis 19.09.2026 stand an dritter Stelle `meldetNichts`: jede Lesequelle
+   mit `read: false` bekam die Marke „aendert sich nie". Gemessen am
+   Produktivsystem traf das 1371 Punkte, 620 davon keine Taster, und 76
+   dieser 620 hatten ihren Wert in den letzten 30 Tagen geaendert -
+   `BOOST_MODE` an den Heizungen etwa. hm-rpc setzt `read: false`, sobald
+   der Wert nicht *abfragbar* ist (OPERATIONS ohne Bit 1); gemeldet wird er
+   trotzdem. Aus dem Feld allein laesst sich nicht ablesen, ob ein Punkt
+   lebt, und wer der Marke folgte, nahm eine funktionierende Lesequelle
+   heraus (Ricardo).
 
    Gibt eine Liste zurueck, nicht ein Urteil — wer sie anzeigt, entscheidet
    ueber die Schaerfe. */
@@ -463,10 +546,5 @@ export function zielKann(s) {
     }
   }
 
-  if (s.srcR) {
-    var r = S.objects[s.srcR];
-    var rc = (r && r.common) || null;
-    if (rc && rc.read === false) { raus.push({ art: 'meldetNichts', punkt: s.srcR }); }
-  }
   return raus;
 }

package/admin/js/zielleiste.js

@@ -11,7 +11,7 @@ import { el } from './basis.js';
 import { tr } from './sprache.js';
 import { enumListe } from './aufzaehlungen.js';
 import { enumZeile, setzeZiel } from './zuordnung.js';
-import { aliasFuer, ordnerUnterAlias, kennungtauglich, knotenDa } from './entwurf.js';
+import { aliasFuer, ausgangsQuellen, ordnerUnterAlias, kennungtauglich, knotenDa } from './entwurf.js';
 import { zeichneErgebnis, entwurfAngefasst, angebotFrisch } from './ergebnis.js';
 import { zeigeVerlegen } from './schreiben.js';
 
@@ -381,7 +381,13 @@ export function baueZielleiste(host, e) {
        irrt sie hier, irrt sie dort ebenso. Und der Hinweis haelt
        niemanden auf. */
     var zwilling = null;
-    var vorhAlias = aliasFuer(e.kanal);
+    /* Dieselbe Frage wie die Vorbelegung, also auch dieselbe Antwort:
+       am Mehrfachgeraet der Alias DIESES Ausgangs. Sonst nennt der
+       Hinweis einen anderen Alias als den, dessen Stand oben in der
+       Liste steht - zwei Aussagen auf einem Bildschirm, die sich
+       widersprechen (C13). */
+    var vorhAlias = aliasFuer(e.kanal, ausgangsQuellen(e)) ||
+      ((e.instanz === null || e.instanz === undefined) ? aliasFuer(e.kanal) : null);
     if (vorhAlias && S.objects[vorhAlias] && vorhAlias !== e.ziel) {
       var zw = el('div', 'uebernahme zwilling');
       zw.appendChild(el('span', 'zq', tr('target.twinExists', vorhAlias)));

package/admin/js/zuordnung.js

@@ -4,7 +4,7 @@
 import { S } from './zustand.js';
 import { el } from './basis.js';
 import { tr, txt } from './sprache.js';
-import { enums, enumsUnbekannt } from './enums.js';
+import { enums, enumsUnbekannt, beiEnumsGeladen } from './enums.js';
 import {
   enumListe,
   enumsVon,
@@ -16,7 +16,8 @@ import { enumVorlagen, katalogFehlt, ikonCache, ikonErlaubt, ikonNachtrag,
          ikonTaugt, vorlageZu, holeIkon } from './katalog.js';
 import { kindZustaende, aliasQuellen, holeEinzelne,
          zeileAusAlias } from './werte.js';
-import { aliasFuer, zielId, knotenDa } from './entwurf.js';
+import { aliasFuer, ausgangsQuellen, zielId, knotenDa,
+         aboErgaenzen, quellenVonEntwurf } from './entwurf.js';
 import { zeichneErgebnis, entwurfAngefasst, angebotFrisch } from './ergebnis.js';
 
 
@@ -237,6 +238,15 @@ export function enumZeile(host, e) {
     ex.title = tr('enums.clear');
     ex.setAttribute('aria-label', tr('enums.clear'));
     ex.hidden = !ei.value;
+    /* Aufzaehlungen nicht geladen: dann wird Raum und Funktion nicht
+       geschrieben, also laesst sich hier auch nichts waehlen. Vorher
+       stand das nur im Trockenlauf, und die Felder sahen aus wie immer
+       (P8, 19.09.2026). */
+    if (enumsUnbekannt()) {
+      ei.disabled = true;
+      ex.disabled = true;
+      ei.title = tr('enums.unknown');
+    }
     ex.addEventListener('mousedown', function (ev) {
       ev.preventDefault();
       e[spec.feld] = '';
@@ -269,7 +279,7 @@ export function enumZeile(host, e) {
     if (spec.art === 'rooms' && e.zuletzt === 'raum' && e.ziel && !aliasFuer(e.kanal)) {
       var ro2 = enumAlsOrdner(e.raum);
       if (ro2 && e.zielOrdner !== 'alias.0.' + ro2) {
-        var oz = el('div', 'uebernahme' +
+        var oz = el('div', 'uebernahme raumangebot' +
           (angebotFrisch('raum:' + ro2) ? ' frisch' : ''));
         oz.appendChild(el('span', 'zq', tr('enums.alsoFolder', ro2)));
         var ob = el('button', 'btn mini wichtig', tr('target.yes'));
@@ -340,15 +350,7 @@ export function enumZeile(host, e) {
                     : (x.anzahl ? tr('enums.members', x.anzahl) : tr('enums.unused'))));
         z.addEventListener('mousedown', function (ev) {
           ev.preventDefault();
-          e[spec.feld] = x.id;
-          e[spec.her] = 'hand';
-          if (spec.art === 'rooms') { e.zuletzt = 'raum'; }
-          /* Das Icon jetzt holen, nicht erst beim Schreiben: dort ist
-             kein Warten mehr moeglich, der Objektbau laeuft synchron. */
-          if (x.vorlage && x.vorlage.icon) { holeIkon(spec.art, x.vorlage.icon); }
-          entwurfAngefasst();
-          zu();
-          zeichneErgebnis();
+          nimm(x);
         });
         el2.appendChild(z);
       });
@@ -365,6 +367,23 @@ export function enumZeile(host, e) {
       el2.hidden = false;
     };
 
+    /* Einen Eintrag der Liste uebernehmen — fuer Mausklick und Enter
+       dieselbe Stelle. Bis 19.09.2026 waren es zwei, und der Enter-Weg
+       vergass zweierlei: `e.zuletzt`, an dem das Angebot „Den Alias auch
+       unter … ablegen?“ haengt, und das Bild einer neuen Aufzaehlung aus
+       den Vorlagen des Admin (Lauf vom 19.09.2026, S3). */
+    function nimm(x) {
+      e[spec.feld] = x.id;
+      e[spec.her] = 'hand';
+      if (spec.art === 'rooms') { e.zuletzt = 'raum'; }
+      /* Das Icon jetzt holen, nicht erst beim Schreiben: dort ist
+         kein Warten mehr moeglich, der Objektbau laeuft synchron. */
+      if (x.vorlage && x.vorlage.icon) { holeIkon(spec.art, x.vorlage.icon); }
+      entwurfAngefasst();
+      zu();
+      zeichneErgebnis();
+    }
+
     ei.addEventListener('focus', function () { ei.value = ''; mMark = -1; malen(); });
     ei.addEventListener('input', function () { mMark = -1; malen(); });
     ei.addEventListener('blur', function () {
@@ -386,18 +405,23 @@ export function enumZeile(host, e) {
       }
       if (ev.key === 'Enter' && !el2.hidden && mListe.length) {
         ev.preventDefault();
-        e[spec.feld] = mListe[mMark >= 0 ? mMark : 0].id;
-        e[spec.her] = 'hand';
-        entwurfAngefasst();
-        zu();
-        zeichneErgebnis();
+        nimm(mListe[mMark >= 0 ? mMark : 0]);
       }
     });
   });
   if (enumAngebot) { ebar.appendChild(enumAngebot); }
   host.appendChild(ebar);
+  if (enumsUnbekannt()) {
+    var eh = el('div', 'aside w', tr('enums.notLoadedField'));
+    eh.style.margin = '4px 0 8px';
+    host.appendChild(eh);
+  }
 }
 
+/* Klappt ein Nachversuch, verschwindet der Hinweis von selbst - sonst
+   stuende er bis zum naechsten Klick da, obwohl alles wieder geht. */
+beiEnumsGeladen(function () { if (S.current) { zeichneErgebnis(); } });
+
 /* Welcher Raum, welche Funktion - und woher.
 
    Gibt es den Alias schon, gilt, was dort steht: seine Zuordnung ist eine
@@ -475,18 +499,35 @@ export function setzeZiel(e) {
       /* Mehrere Ausgaenge: das Geraet wird zum Ordner, jeder Ausgang
          ein Kanal darin. Ein folder darueber, kein device — sonst
          rutscht die Erkennung hoch und macht aus dreien wieder eins. */
-      if (vorhanden) {
-        /* Der gefundene Kanal ist einer der Ausgaenge; der Ordner liegt
-           darueber. Wie der einzelne Ausgang heisst, kann die Werkbank
-           nicht wissen — wer sie umbenannt hat, sieht den Vorschlag in
-           der Zielzeile und kann ihn anpassen. */
-        var tm = vorhanden.split('.');
-        tm.pop();
-        e.zielOrdner = tm.join('.');
+      /* Gibt es den Alias fuer GENAU DIESEN Ausgang, ist er das Ziel —
+         mit seinem eigenen Namen, nicht mit dem der Ausgangsnummer.
+
+         Hier stand: „Wie der einzelne Ausgang heisst, kann die Werkbank
+         nicht wissen." Das galt, solange sie nur nach dem GERAET fragen
+         konnte. Seit `ausgangsQuellen` weiss sie es: Ricardos `RF1000`
+         liest aus `stat.POWER1` und ist damit Ausgang 1. Vorher schlug
+         die Zielzeile `…Steckdosenleiste.POWER1` vor — eine Kennung, die
+         es gar nicht gibt —, meldete „wird neu angelegt" und haette beim
+         Klick einen zweiten Alias neben `RF1000` gesetzt (C13,
+         16.09.2026). */
+      var vorhAus = aliasFuer(S.current, ausgangsQuellen(e));
+      if (vorhAus) {
+        var ta = vorhAus.split('.');
+        e.zielName = ta.pop();
+        e.zielOrdner = ta.join('.');
       } else {
-        e.zielOrdner = zt0.join('.') + '.' + geraet;
+        if (vorhanden) {
+          /* Kein Alias fuer diesen Ausgang, aber einer am Geraet: der gibt
+             wenigstens den Ordner vor. Der Name kommt aus der
+             Ausgangsnummer — hier entsteht wirklich etwas Neues. */
+          var tm = vorhanden.split('.');
+          tm.pop();
+          e.zielOrdner = tm.join('.');
+        } else {
+          e.zielOrdner = zt0.join('.') + '.' + geraet;
+        }
+        e.zielName = ausgangName(e, e.instanz);
       }
-      e.zielName = ausgangName(e, e.instanz);
     } else if (vorhanden) {
       var te = vorhanden.split('.');
       e.zielName = te.pop();
@@ -583,7 +624,10 @@ export function uebernehmeBestand(e) {
   function vomAliasUebernehmen(z, o) {
     var c = o.common || {}, q2 = aliasQuellen(o);
     var ist = zeileAusAlias(o, z.n);
-    if (!z.vorlagenWert) {
+    /* Dieselbe Frage wie in `bestandVorrang`: ohne Vorlage gibt es keinen
+       Vorlagenwert. Sonst verglich die Zeile gegen den Rohentwurf und
+       nannte das „weicht von der Vorlage ab" (17.09.2026). */
+    if (!z.vorlagenWert && e.vorschlag && e.vorlage) {
       z.vorlagenWert = {
         on: z.on, role: z.role, typ: z.typ, unit: z.unit, caption: z.caption,
         f: z.f, fw: z.fw, srcR: z.srcR, srcW: z.srcW, states: z.states
@@ -768,6 +812,13 @@ export function uebernehmeBestand(e) {
       });
     }
   }
+  /* Geholt ist nur der erste Wert - mitlaufen tut er erst mit einem Abo.
+     Die Zeilen aus dem Alias lesen oft aus einem anderen Knoten als dem
+     angeklickten (J9, 18.09.2026: `Stromzaehler` zeigte drei Zeilen „aus
+     Solar.Netz" stundenlang auf dem Stand vom Anklicken). Ergaenzt wird
+     nur, was noch nicht laeuft; bei jedem Zeichnen zu rufen kostet also
+     nichts. */
+  if (S.entwurf === e && e.kanal === S.current) { aboErgaenzen(quellenVonEntwurf(e)); }
 }
 
 export function unterschiede(e) {

package/admin/js/zustand.js

@@ -14,6 +14,11 @@ export var S = {
   objects: {},
   keysSorted: [],
   kleinIndex: {},
+  /* Zaehlt jede Aenderung an S.objects. Wer sich etwas aus den Objekten
+     merkt (die Karte Quelle -> Alias in entwurf.js), vergleicht hiermit
+     statt mit der Zahl der Schluessel — beim Verlegen verschwinden genau
+     so viele, wie dazukommen (T22). */
+  objektStand: 0,
   /* Alias-Kanal -> Zahl der Punkte, deren Quelle es nicht (mehr) gibt.
      Einmal beim Laden gerechnet; der Baum schlaegt nur nach. */
   aliasKaputt: {},
@@ -44,7 +49,6 @@ export var S = {
   loeschListe: [],
   loeschZiel: null,
   loeschAlleAusgaenge: false,
-  verlegeZiel: null,
   /* Einmal registrierter Schliesser fuer die Quellenauswahl am
      Sprungknopf - siehe ergebnis.js. */
   sprungZuhoerer: false,