@rfranzoi/scrypted-mqtt-securitysystem 1.0.44 → 1.0.46

package/dist/main.nodejs.js

@@ -34024,28 +34024,46 @@ function socketOnError() {
 
 "use strict";
 
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-// --- Silence ONLY the optional sdk.json warning from @scrypted/sdk ---
-const __origConsoleError = console.error.bind(console);
-console.error = (...args) => {
-    const first = args?.[0];
-    const msg = typeof first === 'string' ? first : (first?.message || '');
-    if (typeof msg === 'string' && msg.includes('failed to load custom interface descriptors')) {
-        // swallow just this warning
-        return;
-    }
-    __origConsoleError(...args);
-};
-// Carica lo SDK (non tipizziamo qui per non perdere le proprietà runtime)
-const sdk = __webpack_require__(/*! @scrypted/sdk */ "./node_modules/@scrypted/sdk/dist/src/index.js");
-// Valori runtime (enum/classi/manager) dal modulo SDK
-const { ScryptedDeviceBase, ScryptedDeviceType, ScryptedInterface, // valore (enum)
-SecuritySystemMode, // valore (enum)
-systemManager, deviceManager, } = sdk;
+const sdk_1 = __importStar(__webpack_require__(/*! @scrypted/sdk */ "./node_modules/@scrypted/sdk/dist/src/index.js"));
 const mqtt_1 = __importDefault(__webpack_require__(/*! mqtt */ "./node_modules/mqtt/build/index.js"));
+const { systemManager, deviceManager } = sdk_1.default;
 /** utils */
 function truthy(v) {
     if (!v)
@@ -34065,13 +34083,12 @@ function normalize(s) {
 function clamp(n, min, max) {
     return Math.max(min, Math.min(max, n));
 }
-/** SecuritySystem outgoing defaults (PAI-like)
- *  Nota: usare number come chiave evita stranezze con gli enum in TS. */
+/** SecuritySystem outgoing defaults (PAI-like) */
 const DEFAULT_OUTGOING = {
-    [SecuritySystemMode.Disarmed]: 'disarm',
-    [SecuritySystemMode.HomeArmed]: 'arm_home',
-    [SecuritySystemMode.AwayArmed]: 'arm_away',
-    [SecuritySystemMode.NightArmed]: 'arm_night',
+    [sdk_1.SecuritySystemMode.Disarmed]: 'disarm',
+    [sdk_1.SecuritySystemMode.HomeArmed]: 'arm_home',
+    [sdk_1.SecuritySystemMode.AwayArmed]: 'arm_away',
+    [sdk_1.SecuritySystemMode.NightArmed]: 'arm_night',
 };
 /** Parse incoming payload -> final mode (ignore transition states) */
 function payloadToMode(payload) {
@@ -34079,23 +34096,36 @@ function payloadToMode(payload) {
         return;
     const p = normalize(payload.toString());
     if (['disarm', 'disarmed', 'off', '0', 'idle', 'ready'].includes(p))
-        return SecuritySystemMode.Disarmed;
+        return sdk_1.SecuritySystemMode.Disarmed;
     if (['arm_home', 'home', 'stay', 'armed_home'].includes(p))
-        return SecuritySystemMode.HomeArmed;
+        return sdk_1.SecuritySystemMode.HomeArmed;
     if (['arm_away', 'away', 'armed_away', 'away_armed'].includes(p))
-        return SecuritySystemMode.AwayArmed;
+        return sdk_1.SecuritySystemMode.AwayArmed;
     if (['arm_night', 'night', 'armed_night', 'sleep', 'arm_sleep', 'armed_sleep'].includes(p))
-        return SecuritySystemMode.NightArmed;
+        return sdk_1.SecuritySystemMode.NightArmed;
     // transitori: non cambiano il mode
     if (['entry_delay', 'exit_delay', 'pending', 'arming', 'disarming'].includes(p))
         return undefined;
     return undefined;
 }
-class BaseMqttSensor extends ScryptedDeviceBase {
+class BaseMqttSensor extends sdk_1.ScryptedDeviceBase {
     constructor(nativeId, cfg) {
         super(nativeId);
         this.cfg = cfg;
     }
+    /** 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() ?? '';
@@ -34103,56 +34133,80 @@ class BaseMqttSensor extends ScryptedDeviceBase {
         // 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;
+                this.setAndEmit('batteryLevel', n, sdk_1.ScryptedInterface.Battery);
         }
         else if (topic === this.cfg.topics.lowBattery && !this.cfg.topics.batteryLevel) {
-            // se abbiamo SOLO lowBattery (bool):
-            this.batteryLevel = truthy(np) ? 10 : 100;
+            // Solo se abbiamo lowBattery (booleano) ma NON batteryLevel:
+            this.setAndEmit('batteryLevel', truthy(np) ? 10 : 100, sdk_1.ScryptedInterface.Battery);
         }
         // primary handled by subclasses
         this.handlePrimary(topic, np, p);
     }
 }
 class ContactMqttSensor extends BaseMqttSensor {
-    handlePrimary(topic, np) {
+    handlePrimary(topic, np, _raw) {
         if (topic === this.cfg.topics.contact) {
-            this.entryOpen = truthy(np);
+            const v = truthy(np);
+            // usa il setter che emette l'evento di EntrySensor
+            this.setAndEmit?.('entryOpen', v, sdk_1.ScryptedInterface.EntrySensor);
+            // fallback per sicurezza (in alcune minifiche setAndEmit non è visibile):
+            if (this.setAndEmit === undefined) {
+                if (this.entryOpen !== v) {
+                    this.entryOpen = v;
+                    this.onDeviceEvent(sdk_1.ScryptedInterface.EntrySensor, v);
+                }
+            }
         }
     }
 }
 class MotionMqttSensor extends BaseMqttSensor {
-    handlePrimary(topic, np) {
+    handlePrimary(topic, np, _raw) {
         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 {
-    handlePrimary(topic, np) {
+    handlePrimary(topic, np, _raw) {
         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);
+                }
+            }
         }
     }
 }
 /** ----------------- Main Plugin ----------------- */
-class ParadoxMqttSecuritySystem extends ScryptedDeviceBase {
+class ParadoxMqttSecuritySystem extends sdk_1.ScryptedDeviceBase {
     constructor() {
         super();
         // sensor management
@@ -34161,26 +34215,26 @@ class ParadoxMqttSecuritySystem extends ScryptedDeviceBase {
         // (facoltativo) Imposta il device type in UI
         setTimeout(() => {
             try {
-                systemManager.getDeviceById(this.id)?.setType?.(ScryptedDeviceType.SecuritySystem);
+                systemManager.getDeviceById(this.id)?.setType?.(sdk_1.ScryptedDeviceType.SecuritySystem);
             }
             catch { }
         });
         // Default state
         this.securitySystemState = this.securitySystemState || {
-            mode: SecuritySystemMode.Disarmed,
+            mode: sdk_1.SecuritySystemMode.Disarmed,
             supportedModes: [
-                SecuritySystemMode.Disarmed,
-                SecuritySystemMode.HomeArmed,
-                SecuritySystemMode.AwayArmed,
-                SecuritySystemMode.NightArmed,
+                sdk_1.SecuritySystemMode.Disarmed,
+                sdk_1.SecuritySystemMode.HomeArmed,
+                sdk_1.SecuritySystemMode.AwayArmed,
+                sdk_1.SecuritySystemMode.NightArmed,
             ],
         };
         this.online = this.online ?? false;
         // Load sensors config and announce devices
         this.loadSensorsFromStorage();
-        this.discoverSensors().catch((e) => this.console.error('discoverSensors error', e));
+        this.discoverSensors().catch(e => this.console.error('discoverSensors error', e));
         // Connect on start
-        this.connectMqtt().catch((e) => this.console.error('MQTT connect error:', e));
+        this.connectMqtt().catch(e => this.console.error('MQTT connect error:', e));
         // chiusura pulita del client MQTT ai reload/stop del plugin
         try {
             process.once('SIGTERM', () => { try {
@@ -34362,22 +34416,22 @@ class ParadoxMqttSecuritySystem extends ScryptedDeviceBase {
         const manifests = this.sensorsCfg.map(cfg => {
             const nativeId = `sensor:${cfg.id}`;
             const t = cfg.topics || {};
-            const interfaces = [ScryptedInterface.Online];
+            const interfaces = [sdk_1.ScryptedInterface.Online];
             // Tamper solo se c'è un topic tamper
             if (t.tamper)
-                interfaces.push(ScryptedInterface.TamperSensor);
+                interfaces.push(sdk_1.ScryptedInterface.TamperSensor);
             // Interfaccia primaria
             if (cfg.kind === 'contact')
-                interfaces.unshift(ScryptedInterface.EntrySensor);
+                interfaces.unshift(sdk_1.ScryptedInterface.EntrySensor);
             else if (cfg.kind === 'motion')
-                interfaces.unshift(ScryptedInterface.MotionSensor);
+                interfaces.unshift(sdk_1.ScryptedInterface.MotionSensor);
             else
-                interfaces.unshift(ScryptedInterface.OccupancySensor);
+                interfaces.unshift(sdk_1.ScryptedInterface.OccupancySensor);
             // Battery solo se previsto
             if (t.batteryLevel || t.lowBattery) {
-                interfaces.push(ScryptedInterface.Battery);
+                interfaces.push(sdk_1.ScryptedInterface.Battery);
             }
-            return { nativeId, name: cfg.name, type: ScryptedDeviceType.Sensor, interfaces };
+            return { nativeId, name: cfg.name, type: sdk_1.ScryptedDeviceType.Sensor, interfaces };
         });
         // 2) Annuncio
         const dmAny = deviceManager;
@@ -34411,6 +34465,10 @@ class ParadoxMqttSecuritySystem extends ScryptedDeviceBase {
             const hasBattery = !!(cfg.topics.batteryLevel || cfg.topics.lowBattery);
             if (hasBattery && dev.batteryLevel === undefined) {
                 dev.batteryLevel = 100;
+                try {
+                    dev.onDeviceEvent(sdk_1.ScryptedInterface.Battery, 100);
+                }
+                catch { }
             }
         }
         // 4) Rimuovi quelli spariti
@@ -34488,6 +34546,10 @@ class ParadoxMqttSecuritySystem extends 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)
@@ -34496,7 +34558,14 @@ class ParadoxMqttSecuritySystem extends 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 {
@@ -34504,36 +34573,59 @@ class ParadoxMqttSecuritySystem extends 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;
                 }
                 if (topic === tCurrent) {
                     const mode = payloadToMode(payload);
                     const isAlarm = ['alarm', 'triggered'].includes(np);
-                    const current = this.securitySystemState || { mode: SecuritySystemMode.Disarmed };
+                    const current = this.securitySystemState || { mode: sdk_1.SecuritySystemMode.Disarmed };
                     const newState = {
                         mode: mode ?? current.mode,
                         supportedModes: current.supportedModes ?? [
-                            SecuritySystemMode.Disarmed,
-                            SecuritySystemMode.HomeArmed,
-                            SecuritySystemMode.AwayArmed,
-                            SecuritySystemMode.NightArmed,
+                            sdk_1.SecuritySystemMode.Disarmed,
+                            sdk_1.SecuritySystemMode.HomeArmed,
+                            sdk_1.SecuritySystemMode.AwayArmed,
+                            sdk_1.SecuritySystemMode.NightArmed,
                         ],
                         triggered: isAlarm || undefined,
                     };
                     this.securitySystemState = newState;
+                    try {
+                        this.onDeviceEvent(sdk_1.ScryptedInterface.SecuritySystem, newState);
+                    }
+                    catch { }
                     return;
                 }
                 if (topic === tTarget) {
@@ -34573,17 +34665,17 @@ class ParadoxMqttSecuritySystem extends ScryptedDeviceBase {
         this.publishSetTarget(payload);
     }
     async disarmSecuritySystem() {
-        const payload = this.getOutgoing(SecuritySystemMode.Disarmed);
+        const payload = this.getOutgoing(sdk_1.SecuritySystemMode.Disarmed);
         this.console.log('disarmSecuritySystem ->', payload);
-        this.pendingTarget = SecuritySystemMode.Disarmed;
+        this.pendingTarget = sdk_1.SecuritySystemMode.Disarmed;
         this.publishSetTarget(payload);
     }
     getOutgoing(mode) {
         const map = {
-            [SecuritySystemMode.Disarmed]: this.storage.getItem('payloadDisarm') || DEFAULT_OUTGOING[SecuritySystemMode.Disarmed],
-            [SecuritySystemMode.HomeArmed]: this.storage.getItem('payloadHome') || DEFAULT_OUTGOING[SecuritySystemMode.HomeArmed],
-            [SecuritySystemMode.AwayArmed]: this.storage.getItem('payloadAway') || DEFAULT_OUTGOING[SecuritySystemMode.AwayArmed],
-            [SecuritySystemMode.NightArmed]: this.storage.getItem('payloadNight') || DEFAULT_OUTGOING[SecuritySystemMode.NightArmed],
+            [sdk_1.SecuritySystemMode.Disarmed]: this.storage.getItem('payloadDisarm') || DEFAULT_OUTGOING[sdk_1.SecuritySystemMode.Disarmed],
+            [sdk_1.SecuritySystemMode.HomeArmed]: this.storage.getItem('payloadHome') || DEFAULT_OUTGOING[sdk_1.SecuritySystemMode.HomeArmed],
+            [sdk_1.SecuritySystemMode.AwayArmed]: this.storage.getItem('payloadAway') || DEFAULT_OUTGOING[sdk_1.SecuritySystemMode.AwayArmed],
+            [sdk_1.SecuritySystemMode.NightArmed]: this.storage.getItem('payloadNight') || DEFAULT_OUTGOING[sdk_1.SecuritySystemMode.NightArmed],
         };
         return map[mode];
     }

package/package.json

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