@rfranzoi/scrypted-mqtt-securitysystem 1.0.45 → 1.0.47

package/dist/main.nodejs.js

@@ -34077,12 +34077,8 @@ function falsy(v) {
     const s = v.toString().trim().toLowerCase();
     return s === '0' || s === 'false' || s === 'offline' || s === 'no' || s === 'off';
 }
-function normalize(s) {
-    return (s || '').trim().toLowerCase();
-}
-function clamp(n, min, max) {
-    return Math.max(min, Math.min(max, n));
-}
+function normalize(s) { return (s || '').trim().toLowerCase(); }
+function clamp(n, min, max) { return Math.max(min, Math.min(max, n)); }
 /** SecuritySystem outgoing defaults (PAI-like) */
 const DEFAULT_OUTGOING = {
     [sdk_1.SecuritySystemMode.Disarmed]: 'disarm',
@@ -34103,7 +34099,6 @@ function payloadToMode(payload) {
         return sdk_1.SecuritySystemMode.AwayArmed;
     if (['arm_night', 'night', 'armed_night', 'sleep', 'arm_sleep', 'armed_sleep'].includes(p))
         return sdk_1.SecuritySystemMode.NightArmed;
-    // transitori: non cambiano il mode
     if (['entry_delay', 'exit_delay', 'pending', 'arming', 'disarming'].includes(p))
         return undefined;
     return undefined;
@@ -34112,71 +34107,100 @@ class BaseMqttSensor extends sdk_1.ScryptedDeviceBase {
     constructor(nativeId, cfg) {
         super(nativeId);
         this.cfg = cfg;
-        // non impostare stati qui: l'annuncio device deve avvenire prima
+    }
+    /** setter centralizzato: cambia lo stato SOLO se diverso e poi emette l'evento relativo */
+    setAndEmit(prop, val, iface) {
+        const prev = this[prop];
+        if (prev === val)
+            return;
+        this[prop] = val;
+        try {
+            this.onDeviceEvent(iface, val);
+        }
+        catch (e) {
+            this.console?.warn?.('onDeviceEvent error', iface, e);
+        }
     }
     /** Called by parent on each MQTT message */
     handleMqtt(topic, payload) {
-        const p = payload?.toString() ?? '';
-        const np = normalize(p);
+        const raw = payload?.toString() ?? '';
+        const np = normalize(raw);
         // online
         if (topic === this.cfg.topics.online) {
             if (truthy(np) || np === 'online')
-                this.online = true;
+                this.setAndEmit('online', true, sdk_1.ScryptedInterface.Online);
             if (falsy(np) || np === 'offline')
-                this.online = false;
+                this.setAndEmit('online', false, sdk_1.ScryptedInterface.Online);
         }
         // tamper
         if (topic === this.cfg.topics.tamper) {
             if (truthy(np) || ['tamper', 'intrusion', 'cover', 'motion', 'magnetic'].includes(np)) {
-                this.tampered = ['cover', 'intrusion', 'motion', 'magnetic'].find(x => x === np) || true;
+                const value = ['cover', 'intrusion', 'motion', 'magnetic'].find(x => x === np) || true;
+                this.setAndEmit('tampered', value, sdk_1.ScryptedInterface.TamperSensor);
             }
             else if (falsy(np)) {
-                this.tampered = false;
+                this.setAndEmit('tampered', false, sdk_1.ScryptedInterface.TamperSensor);
             }
         }
         // battery
         if (topic === this.cfg.topics.batteryLevel) {
-            const n = clamp(parseFloat(p), 0, 100);
-            if (isFinite(n))
-                this.batteryLevel = n;
+            // aggiorna solo con numeri validi 0..100
+            const n = clamp(parseFloat(raw), 0, 100);
+            if (Number.isFinite(n))
+                this.setAndEmit('batteryLevel', n, sdk_1.ScryptedInterface.Battery);
         }
         else if (topic === this.cfg.topics.lowBattery && !this.cfg.topics.batteryLevel) {
-            // Solo se abbiamo lowBattery (booleano) ma NON batteryLevel:
-            // True  -> 10% (warning)
-            // False -> 100% (ok)
-            this.batteryLevel = truthy(np) ? 10 : 100;
+            // LowBattery booleano: quando TRUE -> 10%; quando FALSE non forzare nulla, lascia il valore precedente
+            if (truthy(np))
+                this.setAndEmit('batteryLevel', 10, sdk_1.ScryptedInterface.Battery);
+            else if (falsy(np) && this.batteryLevel === undefined) {
+                // se è il primo messaggio ed è "ok", metti 100 (altrimenti resta undefined)
+                this.setAndEmit('batteryLevel', 100, sdk_1.ScryptedInterface.Battery);
+            }
         }
         // primary handled by subclasses
-        this.handlePrimary(topic, np, p);
+        this.handlePrimary(topic, np, raw);
     }
 }
 class ContactMqttSensor extends BaseMqttSensor {
-    constructor(nativeId, cfg) {
-        super(nativeId, cfg);
-    }
-    handlePrimary(topic, np, _raw) {
+    handlePrimary(topic, np) {
         if (topic === this.cfg.topics.contact) {
-            this.entryOpen = truthy(np);
+            const v = truthy(np);
+            this.setAndEmit?.('entryOpen', v, sdk_1.ScryptedInterface.EntrySensor);
+            if (this.setAndEmit === undefined) {
+                if (this.entryOpen !== v) {
+                    this.entryOpen = v;
+                    this.onDeviceEvent(sdk_1.ScryptedInterface.EntrySensor, v);
+                }
+            }
         }
     }
 }
 class MotionMqttSensor extends BaseMqttSensor {
-    constructor(nativeId, cfg) {
-        super(nativeId, cfg);
-    }
-    handlePrimary(topic, np, _raw) {
+    handlePrimary(topic, np) {
         if (topic === this.cfg.topics.motion) {
-            this.motionDetected = truthy(np);
+            const v = truthy(np);
+            this.setAndEmit?.('motionDetected', v, sdk_1.ScryptedInterface.MotionSensor);
+            if (this.setAndEmit === undefined) {
+                if (this.motionDetected !== v) {
+                    this.motionDetected = v;
+                    this.onDeviceEvent(sdk_1.ScryptedInterface.MotionSensor, v);
+                }
+            }
         }
     }
 }
 class OccupancyMqttSensor extends BaseMqttSensor {
-    constructor(nativeId, cfg) {
-        super(nativeId, cfg);
-    }
-    handlePrimary(topic, np, _raw) {
+    handlePrimary(topic, np) {
         if (topic === this.cfg.topics.occupancy) {
-            this.occupied = truthy(np);
+            const v = truthy(np);
+            this.setAndEmit?.('occupied', v, sdk_1.ScryptedInterface.OccupancySensor);
+            if (this.setAndEmit === undefined) {
+                if (this.occupied !== v) {
+                    this.occupied = v;
+                    this.onDeviceEvent(sdk_1.ScryptedInterface.OccupancySensor, v);
+                }
+            }
         }
     }
 }
@@ -34277,7 +34301,6 @@ class ParadoxMqttSecuritySystem extends sdk_1.ScryptedDeviceBase {
         return out;
     }
     async putSetting(key, value) {
-        // salva sempre nella storage la value del campo (così resta in UI)
         this.storage.setItem(key, String(value));
         // --- Add Sensor workflow ---
         if (key === 'new.create' && String(value) === 'true') {
@@ -34294,7 +34317,6 @@ class ParadoxMqttSecuritySystem extends sdk_1.ScryptedDeviceBase {
             }
             this.sensorsCfg.push({ id, name, kind, topics: {} });
             this.saveSensorsToStorage();
-            // pulisci i campi "new.*"
             this.storage.removeItem('new.id');
             this.storage.removeItem('new.name');
             this.storage.removeItem('new.kind');
@@ -34314,7 +34336,6 @@ class ParadoxMqttSecuritySystem extends sdk_1.ScryptedDeviceBase {
                 return;
             }
             if (prop === 'remove' && String(value) === 'true') {
-                // elimina
                 this.sensorsCfg = this.sensorsCfg.filter(s => s.id !== sid);
                 this.saveSensorsToStorage();
                 try {
@@ -34322,18 +34343,15 @@ class ParadoxMqttSecuritySystem extends sdk_1.ScryptedDeviceBase {
                     deviceManager.onDeviceRemoved?.(`sensor:${sid}`);
                 }
                 catch { }
-                // pulisci flag
                 this.storage.removeItem(key);
                 await this.discoverSensors();
                 await this.connectMqtt(true);
                 return;
             }
-            if (prop === 'name') {
+            if (prop === 'name')
                 cfg.name = String(value);
-            }
-            else if (prop === 'kind') {
+            else if (prop === 'kind')
                 cfg.kind = String(value);
-            }
             else if (prop.startsWith('topic.')) {
                 const tk = prop.substring('topic.'.length);
                 cfg.topics[tk] = String(value).trim();
@@ -34345,7 +34363,6 @@ class ParadoxMqttSecuritySystem extends sdk_1.ScryptedDeviceBase {
         }
         // --- Altro (MQTT / Alarm settings) ---
         if (key === 'sensorsJson') {
-            // non più mostrato, ma se presente da vecchie versioni
             this.loadSensorsFromStorage();
             await this.discoverSensors();
             await this.connectMqtt(true);
@@ -34361,9 +34378,8 @@ class ParadoxMqttSecuritySystem extends sdk_1.ScryptedDeviceBase {
     async releaseDevice(_id, nativeId) {
         try {
             const dev = this.devices.get(nativeId);
-            if (dev) {
+            if (dev)
                 this.devices.delete(nativeId);
-            }
             try {
                 deviceManager.onDeviceRemoved?.(nativeId);
             }
@@ -34377,7 +34393,6 @@ class ParadoxMqttSecuritySystem extends sdk_1.ScryptedDeviceBase {
         try {
             const raw = this.storage.getItem('sensorsJson') || '[]';
             const parsed = JSON.parse(raw);
-            // sanitize
             this.sensorsCfg = (parsed || []).filter(x => x && x.id && x.name && x.kind && x.topics);
         }
         catch (e) {
@@ -34387,23 +34402,21 @@ class ParadoxMqttSecuritySystem extends sdk_1.ScryptedDeviceBase {
     }
     /** ===== discoverSensors: annuncia PRIMA, istanzia DOPO ===== */
     async discoverSensors() {
-        // 1) Prepara i manifest (niente istanze qui)
+        // 1) Manifests
         const manifests = this.sensorsCfg.map(cfg => {
             const nativeId = `sensor:${cfg.id}`;
             const t = cfg.topics || {};
             const interfaces = [sdk_1.ScryptedInterface.Online];
-            // Tamper solo se c'è un topic tamper
             if (t.tamper)
                 interfaces.push(sdk_1.ScryptedInterface.TamperSensor);
-            // Interfaccia primaria
             if (cfg.kind === 'contact')
                 interfaces.unshift(sdk_1.ScryptedInterface.EntrySensor);
             else if (cfg.kind === 'motion')
                 interfaces.unshift(sdk_1.ScryptedInterface.MotionSensor);
             else
                 interfaces.unshift(sdk_1.ScryptedInterface.OccupancySensor);
-            // Battery solo se previsto
-            if (t.batteryLevel || t.lowBattery) {
+            // Espone Battery SOLTANTO se è configurato almeno un topic batteria (stringa non vuota)
+            if ((t.batteryLevel && t.batteryLevel.trim()) || (t.lowBattery && t.lowBattery.trim())) {
                 interfaces.push(sdk_1.ScryptedInterface.Battery);
             }
             return { nativeId, name: cfg.name, type: sdk_1.ScryptedDeviceType.Sensor, interfaces };
@@ -34436,11 +34449,7 @@ class ParadoxMqttSecuritySystem extends sdk_1.ScryptedDeviceBase {
             else {
                 dev.cfg = cfg;
             }
-            // Default “OK” se abbiamo Battery ma nessun valore ancora ricevuto
-            const hasBattery = !!(cfg.topics.batteryLevel || cfg.topics.lowBattery);
-            if (hasBattery && dev.batteryLevel === undefined) {
-                dev.batteryLevel = 100;
-            }
+            // <<< RIMOSSO il default batteryLevel=100: niente valore finché non arriva un messaggio >>>
         }
         // 4) Rimuovi quelli spariti
         const announced = new Set(manifests.map(m => m.nativeId));
@@ -34488,7 +34497,7 @@ class ParadoxMqttSecuritySystem extends sdk_1.ScryptedDeviceBase {
         for (const s of this.sensorsCfg) {
             const t = s.topics || {};
             [t.contact, t.motion, t.occupancy, t.batteryLevel, t.lowBattery, t.tamper, t.online]
-                .filter(Boolean)
+                .filter((x) => !!x && String(x).trim().length > 0)
                 .forEach(x => subs.add(String(x)));
         }
         return Array.from(subs);
@@ -34517,6 +34526,10 @@ class ParadoxMqttSecuritySystem extends sdk_1.ScryptedDeviceBase {
         client.on('connect', () => {
             this.console.log('MQTT connected');
             this.online = true;
+            try {
+                this.onDeviceEvent(sdk_1.ScryptedInterface.Online, true);
+            }
+            catch { }
             if (subs.length) {
                 client.subscribe(subs, { qos: 0 }, (err) => {
                     if (err)
@@ -34525,7 +34538,14 @@ class ParadoxMqttSecuritySystem extends sdk_1.ScryptedDeviceBase {
             }
         });
         client.on('reconnect', () => this.console.log('MQTT reconnecting...'));
-        client.on('close', () => { this.console.log('MQTT closed'); this.online = false; });
+        client.on('close', () => {
+            this.console.log('MQTT closed');
+            this.online = false;
+            try {
+                this.onDeviceEvent(sdk_1.ScryptedInterface.Online, false);
+            }
+            catch { }
+        });
         client.on('error', (e) => { this.console.error('MQTT error', e); });
         client.on('message', (topic, payload) => {
             try {
@@ -34533,18 +34553,37 @@ class ParadoxMqttSecuritySystem extends sdk_1.ScryptedDeviceBase {
                 const np = normalize(p);
                 // ---- Alarm handling ----
                 if (topic === tOnline) {
-                    if (truthy(np) || np === 'online')
+                    if (truthy(np) || np === 'online') {
                         this.online = true;
-                    if (falsy(np) || np === 'offline')
+                        try {
+                            this.onDeviceEvent(sdk_1.ScryptedInterface.Online, true);
+                        }
+                        catch { }
+                    }
+                    if (falsy(np) || np === 'offline') {
                         this.online = false;
+                        try {
+                            this.onDeviceEvent(sdk_1.ScryptedInterface.Online, false);
+                        }
+                        catch { }
+                    }
                     return;
                 }
                 if (topic === tTamper) {
                     if (truthy(np) || ['tamper', 'intrusion', 'cover'].includes(np)) {
-                        this.tampered = ['cover', 'intrusion'].find(x => x === np) || true;
+                        const val = ['cover', 'intrusion'].find(x => x === np) || true;
+                        this.tampered = val;
+                        try {
+                            this.onDeviceEvent(sdk_1.ScryptedInterface.TamperSensor, val);
+                        }
+                        catch { }
                     }
                     else if (falsy(np)) {
                         this.tampered = false;
+                        try {
+                            this.onDeviceEvent(sdk_1.ScryptedInterface.TamperSensor, false);
+                        }
+                        catch { }
                     }
                     return;
                 }
@@ -34563,6 +34602,10 @@ class ParadoxMqttSecuritySystem extends sdk_1.ScryptedDeviceBase {
                         triggered: isAlarm || undefined,
                     };
                     this.securitySystemState = newState;
+                    try {
+                        this.onDeviceEvent(sdk_1.ScryptedInterface.SecuritySystem, newState);
+                    }
+                    catch { }
                     return;
                 }
                 if (topic === tTarget) {
@@ -34598,7 +34641,7 @@ class ParadoxMqttSecuritySystem extends sdk_1.ScryptedDeviceBase {
     async armSecuritySystem(mode) {
         const payload = this.getOutgoing(mode);
         this.console.log('armSecuritySystem', mode, '->', payload);
-        this.pendingTarget = mode; // memorizza target, ma NON cambiare il current
+        this.pendingTarget = mode;
         this.publishSetTarget(payload);
     }
     async disarmSecuritySystem() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rfranzoi/scrypted-mqtt-securitysystem",
-  "version": "1.0.45",
+  "version": "1.0.47",
   "description": "Scrypted plugin: Paradox Security System via MQTT (PAI/PAI-MQTT style).",
   "license": "MIT",
   "main": "dist/main.nodejs.js",