homebridge-ring 11.5.0 → 11.5.1

package/lib/base-accessory.js

@@ -1,21 +1,18 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "BaseAccessory", {
-    enumerable: true,
-    get: ()=>BaseAccessory
-});
-const _hap = require("./hap");
-const _operators = require("rxjs/operators");
-const _rxjs = require("rxjs");
-const _config = require("./config");
-const _homebridge = require("homebridge");
-const _util = require("ring-client-api/util");
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseAccessory = void 0;
+const hap_1 = require("./hap");
+const operators_1 = require("rxjs/operators");
+const rxjs_1 = require("rxjs");
+const config_1 = require("./config");
+const util_1 = require("ring-client-api/util");
 function isServiceInstance(serviceType) {
     return typeof serviceType === 'object';
 }
 class BaseAccessory {
+    constructor() {
+        this.servicesInUse = [];
+    }
     initBase() {
         this.pruneUnusedServices();
     }
@@ -23,11 +20,16 @@ class BaseAccessory {
         if (isServiceInstance(serviceType)) {
             return serviceType;
         }
-        if (_config.debug) {
+        if (config_1.debug) {
             name = 'TEST ' + name;
         }
-        const existingService = subType ? this.accessory.getServiceById(serviceType, subType) : this.accessory.getService(serviceType), service = existingService || this.accessory.addService(serviceType, name, subType);
-        if (_config.debug && existingService && existingService.displayName && name !== existingService.displayName) {
+        const existingService = subType
+            ? this.accessory.getServiceById(serviceType, subType)
+            : this.accessory.getService(serviceType), service = existingService || this.accessory.addService(serviceType, name, subType);
+        if (config_1.debug &&
+            existingService &&
+            existingService.displayName &&
+            name !== existingService.displayName) {
             throw new Error(`Overlapping services for device ${this.device.name} - ${name} != ${existingService.displayName} - ${serviceType}`);
         }
         if (!this.servicesInUse.includes(service)) {
@@ -35,30 +37,31 @@ class BaseAccessory {
         }
         return service;
     }
-    registerObservableCharacteristic({ characteristicType , serviceType , serviceSubType , onValue , setValue , name , requestUpdate  }) {
-        const service = this.getService(serviceType, name, serviceSubType), characteristic = service.getCharacteristic(characteristicType), onCachedValue = onValue.pipe((0, _operators.shareReplay)(1));
-        onCachedValue.subscribe((value)=>{
+    registerObservableCharacteristic({ characteristicType, serviceType, serviceSubType, onValue, setValue, name, requestUpdate, }) {
+        const service = this.getService(serviceType, name, serviceSubType), characteristic = service.getCharacteristic(characteristicType), onCachedValue = onValue.pipe((0, operators_1.shareReplay)(1));
+        onCachedValue.subscribe((value) => {
             characteristic.updateValue(value);
         });
         if (requestUpdate) {
             // Only register for GET if an async request should be made to get an updated value
-            onCachedValue.pipe((0, _operators.take)(1)).subscribe(()=>{
+            onCachedValue.pipe((0, operators_1.take)(1)).subscribe(() => {
                 // allow GET once a value is cached
-                characteristic.on(_homebridge.CharacteristicEventTypes.GET, async (callback)=>{
+                characteristic.on("get" /* CharacteristicEventTypes.GET */, async (callback) => {
                     try {
-                        const value = await (0, _rxjs.firstValueFrom)(onCachedValue);
+                        const value = await (0, rxjs_1.firstValueFrom)(onCachedValue);
                         callback(null, value);
                         requestUpdate();
-                    } catch (e) {
+                    }
+                    catch (e) {
                         callback(e);
                     }
                 });
             });
         }
         if (setValue) {
-            characteristic.on(_homebridge.CharacteristicEventTypes.SET, (newValue, callback)=>{
-                Promise.resolve(setValue(newValue)).catch((e)=>{
-                    (0, _util.logError)(e);
+            characteristic.on("set" /* CharacteristicEventTypes.SET */, (newValue, callback) => {
+                Promise.resolve(setValue(newValue)).catch((e) => {
+                    (0, util_1.logError)(e);
                 });
                 callback();
             });
@@ -66,17 +69,16 @@ class BaseAccessory {
     }
     pruneUnusedServices() {
         const safeServiceUUIDs = [
-            _hap.hap.Service.CameraRTPStreamManagement.UUID,
-            _hap.hap.Service.CameraControl.UUID
+            hap_1.hap.Service.CameraRTPStreamManagement.UUID,
+            hap_1.hap.Service.CameraControl.UUID,
         ];
-        this.accessory.services.forEach((service)=>{
-            if (!this.servicesInUse.includes(service) && !safeServiceUUIDs.includes(service.UUID)) {
-                (0, _util.logInfo)('Pruning unused service', service.UUID, service.displayName || service.name, 'from', this.device.name);
+        this.accessory.services.forEach((service) => {
+            if (!this.servicesInUse.includes(service) &&
+                !safeServiceUUIDs.includes(service.UUID)) {
+                (0, util_1.logInfo)('Pruning unused service', service.UUID, service.displayName || service.name, 'from', this.device.name);
                 this.accessory.removeService(service);
             }
         });
     }
-    constructor(){
-        this.servicesInUse = [];
-    }
 }
+exports.BaseAccessory = BaseAccessory;

package/lib/base-data-accessory.js

@@ -1,64 +1,64 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "BaseDataAccessory", {
-    enumerable: true,
-    get: ()=>BaseDataAccessory
-});
-const _baseAccessory = require("./base-accessory");
-const _rxjs = require("rxjs");
-const _operators = require("rxjs/operators");
-const _homebridge = require("homebridge");
-const _util = require("ring-client-api/util");
-class BaseDataAccessory extends _baseAccessory.BaseAccessory {
-    registerCharacteristic({ characteristicType , serviceType , getValue , setValue , setValueDebounceTime =0 , name , requestUpdate , serviceSubType  }) {
-        const service = this.getService(serviceType, name, serviceSubType), characteristic = service.getCharacteristic(characteristicType), { device  } = this;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseDataAccessory = void 0;
+const base_accessory_1 = require("./base-accessory");
+const rxjs_1 = require("rxjs");
+const operators_1 = require("rxjs/operators");
+const util_1 = require("ring-client-api/util");
+class BaseDataAccessory extends base_accessory_1.BaseAccessory {
+    registerCharacteristic({ characteristicType, serviceType, getValue, setValue, setValueDebounceTime = 0, name, requestUpdate, serviceSubType, }) {
+        const service = this.getService(serviceType, name, serviceSubType), characteristic = service.getCharacteristic(characteristicType), { device } = this;
         if (requestUpdate) {
             // Only register for GET if an async request should be made to get an updated value
-            characteristic.on(_homebridge.CharacteristicEventTypes.GET, (callback)=>{
+            characteristic.on("get" /* CharacteristicEventTypes.GET */, (callback) => {
                 try {
                     const value = getValue(device.data);
                     callback(null, value);
                     requestUpdate();
-                } catch (e) {
+                }
+                catch (e) {
                     callback(e);
                 }
             });
         }
         if (setValue && setValueDebounceTime) {
-            const onValueToSet = new _rxjs.Subject();
-            characteristic.on(_homebridge.CharacteristicEventTypes.SET, (newValue, callback)=>{
+            const onValueToSet = new rxjs_1.Subject();
+            characteristic.on("set" /* CharacteristicEventTypes.SET */, (newValue, callback) => {
                 onValueToSet.next(newValue);
                 callback();
             });
-            onValueToSet.pipe((0, _operators.debounceTime)(setValueDebounceTime)).subscribe(setValue);
-        } else if (setValue) {
-            characteristic.on(_homebridge.CharacteristicEventTypes.SET, (newValue, callback)=>{
-                Promise.resolve(setValue(newValue)).catch(_util.logError);
+            onValueToSet.pipe((0, operators_1.debounceTime)(setValueDebounceTime)).subscribe(setValue);
+        }
+        else if (setValue) {
+            characteristic.on("set" /* CharacteristicEventTypes.SET */, (newValue, callback) => {
+                Promise.resolve(setValue(newValue)).catch(util_1.logError);
                 callback();
             });
         }
-        this.device.onData.pipe((0, _operators.map)(getValue), (0, _operators.distinctUntilChanged)()).subscribe((value)=>characteristic.updateValue(value));
+        ;
+        this.device.onData
+            .pipe((0, operators_1.map)(getValue), (0, operators_1.distinctUntilChanged)())
+            .subscribe((value) => characteristic.updateValue(value));
     }
-    registerLevelCharacteristic({ characteristicType , serviceType , getValue , setValue , requestUpdate  }) {
+    registerLevelCharacteristic({ characteristicType, serviceType, getValue, setValue, requestUpdate, }) {
         let targetLevel;
         this.registerCharacteristic({
             characteristicType,
             serviceType,
-            getValue: (data)=>{
+            getValue: (data) => {
                 const newLevel = getValue(data);
                 if (newLevel === targetLevel) {
                     targetLevel = undefined;
                 }
                 return targetLevel === undefined ? newLevel : targetLevel;
             },
-            setValue: (level)=>{
+            setValue: (level) => {
                 targetLevel = level;
                 setValue(level);
             },
             setValueDebounceTime: 500,
-            requestUpdate
+            requestUpdate,
         });
     }
 }
+exports.BaseDataAccessory = BaseDataAccessory;

package/lib/base-device-accessory.js

@@ -1,30 +1,33 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "BaseDeviceAccessory", {
-    enumerable: true,
-    get: ()=>BaseDeviceAccessory
-});
-const _hap = require("./hap");
-const _baseDataAccessory = require("./base-data-accessory");
-function getBatteryLevel({ batteryLevel , batteryStatus  }) {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseDeviceAccessory = void 0;
+const hap_1 = require("./hap");
+const base_data_accessory_1 = require("./base-data-accessory");
+function getBatteryLevel({ batteryLevel, batteryStatus }) {
     if (batteryLevel !== undefined) {
         return batteryLevel;
-    } else if (batteryStatus === 'full' || batteryStatus === 'charged') {
+    }
+    else if (batteryStatus === 'full' || batteryStatus === 'charged') {
         return 100;
-    } else if (batteryStatus === 'ok' || batteryStatus === 'charging') {
+    }
+    else if (batteryStatus === 'ok' || batteryStatus === 'charging') {
         return 50;
     }
     return 0;
 }
 function getStatusLowBattery(data) {
-    const { StatusLowBattery  } = _hap.hap.Characteristic, batteryLevel = getBatteryLevel(data);
-    return batteryLevel > 20 ? StatusLowBattery.BATTERY_LEVEL_NORMAL : StatusLowBattery.BATTERY_LEVEL_LOW;
+    const { StatusLowBattery } = hap_1.hap.Characteristic, batteryLevel = getBatteryLevel(data);
+    return batteryLevel > 20
+        ? StatusLowBattery.BATTERY_LEVEL_NORMAL
+        : StatusLowBattery.BATTERY_LEVEL_LOW;
 }
-function getBatteryChargingState({ batteryStatus , batteryBackup , acStatus  }) {
-    const { ChargingState  } = _hap.hap.Characteristic;
-    if (batteryStatus === 'charging' || batteryStatus === 'charged' || batteryBackup === 'charged' || batteryBackup === 'charging' || acStatus === 'ok') {
+function getBatteryChargingState({ batteryStatus, batteryBackup, acStatus, }) {
+    const { ChargingState } = hap_1.hap.Characteristic;
+    if (batteryStatus === 'charging' ||
+        batteryStatus === 'charged' ||
+        batteryBackup === 'charged' ||
+        batteryBackup === 'charging' ||
+        acStatus === 'ok') {
         return ChargingState.CHARGING;
     }
     if (batteryBackup === 'inUse' || acStatus === 'error') {
@@ -32,76 +35,79 @@ function getBatteryChargingState({ batteryStatus , batteryBackup , acStatus  })
     }
     return ChargingState.NOT_CHARGEABLE;
 }
-function hasBatteryStatus({ batteryStatus  }) {
+function hasBatteryStatus({ batteryStatus }) {
     return batteryStatus !== 'none';
 }
-class BaseDeviceAccessory extends _baseDataAccessory.BaseDataAccessory {
+class BaseDeviceAccessory extends base_data_accessory_1.BaseDataAccessory {
     initBase() {
-        const { device: { data: initialData  } , device  } = this, { Characteristic , Service  } = _hap.hap;
+        const { device: { data: initialData }, device, } = this, { Characteristic, Service } = hap_1.hap;
         this.registerCharacteristic({
             characteristicType: Characteristic.Manufacturer,
             serviceType: Service.AccessoryInformation,
-            getValue: (data)=>data.manufacturerName || 'Ring'
+            getValue: (data) => data.manufacturerName || 'Ring',
         });
         this.registerCharacteristic({
             characteristicType: Characteristic.Model,
             serviceType: Service.AccessoryInformation,
-            getValue: (data)=>data.deviceType
+            getValue: (data) => data.deviceType,
         });
         this.registerCharacteristic({
             characteristicType: Characteristic.SerialNumber,
             serviceType: Service.AccessoryInformation,
-            getValue: (data)=>data.serialNumber || 'Unknown'
+            getValue: (data) => data.serialNumber || 'Unknown',
         });
         if ('volume' in initialData && 'setVolume' in device) {
             this.registerCharacteristic({
                 characteristicType: Characteristic.Mute,
                 serviceType: Service.Speaker,
-                getValue: ()=>false
+                getValue: () => false,
             });
             this.registerLevelCharacteristic({
                 characteristicType: Characteristic.Volume,
                 serviceType: Service.Speaker,
-                getValue: (data)=>{
+                getValue: (data) => {
                     return data.volume ? data.volume * 100 : 0;
                 },
-                setValue: (volume)=>device.setVolume(volume / 100)
+                setValue: (volume) => device.setVolume(volume / 100),
             });
         }
         if (hasBatteryStatus(initialData)) {
             this.registerCharacteristic({
                 characteristicType: Characteristic.BatteryLevel,
                 serviceType: Service.BatteryService,
-                getValue: getBatteryLevel
+                getValue: getBatteryLevel,
             });
             this.registerCharacteristic({
                 characteristicType: Characteristic.StatusLowBattery,
                 serviceType: Service.BatteryService,
-                getValue: getStatusLowBattery
+                getValue: getStatusLowBattery,
             });
             this.registerCharacteristic({
                 characteristicType: Characteristic.ChargingState,
                 serviceType: Service.BatteryService,
-                getValue: getBatteryChargingState
+                getValue: getBatteryChargingState,
             });
         }
         super.initBase();
     }
     initSensorService(serviceType) {
-        const { Characteristic  } = _hap.hap;
+        const { Characteristic } = hap_1.hap;
         this.registerCharacteristic({
             characteristicType: Characteristic.StatusTampered,
             serviceType,
-            getValue: (data)=>{
-                return data.tamperStatus === 'ok' ? Characteristic.StatusTampered.NOT_TAMPERED : Characteristic.StatusTampered.TAMPERED;
-            }
+            getValue: (data) => {
+                return data.tamperStatus === 'ok'
+                    ? Characteristic.StatusTampered.NOT_TAMPERED
+                    : Characteristic.StatusTampered.TAMPERED;
+            },
         });
         if (hasBatteryStatus(this.device.data)) {
             this.registerCharacteristic({
                 characteristicType: Characteristic.StatusLowBattery,
                 serviceType,
-                getValue: (data)=>getStatusLowBattery(data)
+                getValue: (data) => getStatusLowBattery(data),
             });
         }
     }
 }
+exports.BaseDeviceAccessory = BaseDeviceAccessory;

package/lib/beam.js

@@ -1,74 +1,64 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "Beam", {
-    enumerable: true,
-    get: ()=>Beam
-});
-const _ringClientApi = require("ring-client-api");
-const _hap = require("./hap");
-const _baseDeviceAccessory = require("./base-device-accessory");
-const _util = require("ring-client-api/util");
-class Beam extends _baseDeviceAccessory.BaseDeviceAccessory {
-    setOnState(on) {
-        (0, _util.logInfo)(`Turning ${this.device.name} ${on ? 'On' : 'Off'}`);
-        const { beamDurationSeconds  } = this.config, duration = beamDurationSeconds ? Math.min(beamDurationSeconds, 32767) : undefined;
-        if (this.isLightGroup && this.groupId) {
-            return this.device.location.setLightGroup(this.groupId, on, duration);
-        }
-        const data = on ? {
-            lightMode: 'on',
-            duration
-        } : {
-            lightMode: 'default'
-        };
-        return this.device.sendCommand('light-mode.set', data);
-    }
-    setLevelState(level) {
-        (0, _util.logInfo)(`Setting brightness of ${this.device.name} to ${level}%`);
-        return this.device.setInfo({
-            device: {
-                v1: {
-                    level: level / 100
-                }
-            }
-        });
-    }
-    constructor(device, accessory, config){
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Beam = void 0;
+const ring_client_api_1 = require("ring-client-api");
+const hap_1 = require("./hap");
+const base_device_accessory_1 = require("./base-device-accessory");
+const util_1 = require("ring-client-api/util");
+class Beam extends base_device_accessory_1.BaseDeviceAccessory {
+    constructor(device, accessory, config) {
         super();
         this.device = device;
         this.accessory = accessory;
         this.config = config;
-        this.isLightGroup = this.device.data.deviceType === _ringClientApi.RingDeviceType.BeamsLightGroupSwitch;
+        this.isLightGroup = this.device.data.deviceType === ring_client_api_1.RingDeviceType.BeamsLightGroupSwitch;
         this.groupId = this.device.data.groupId;
-        const { Characteristic , Service  } = _hap.hap, { MotionSensor  } = Service, { data: { deviceType  }  } = this.device;
-        if (deviceType !== _ringClientApi.RingDeviceType.BeamsMotionSensor) {
+        const { Characteristic, Service } = hap_1.hap, { MotionSensor } = Service, { data: { deviceType }, } = this.device;
+        if (deviceType !== ring_client_api_1.RingDeviceType.BeamsMotionSensor) {
             this.registerCharacteristic({
                 characteristicType: Characteristic.On,
                 serviceType: Service.Lightbulb,
-                getValue: (data)=>Boolean(data.on),
-                setValue: (value)=>this.setOnState(value)
+                getValue: (data) => Boolean(data.on),
+                setValue: (value) => this.setOnState(value),
             });
             this.getService(Service.Lightbulb).setPrimaryService(true);
         }
-        if (deviceType === _ringClientApi.RingDeviceType.BeamsMultiLevelSwitch) {
+        if (deviceType === ring_client_api_1.RingDeviceType.BeamsMultiLevelSwitch) {
             this.registerLevelCharacteristic({
                 characteristicType: Characteristic.Brightness,
                 serviceType: Service.Lightbulb,
-                getValue: (data)=>{
+                getValue: (data) => {
                     return data.level && !isNaN(data.level) ? 100 * data.level : 0;
                 },
-                setValue: (value)=>this.setLevelState(value)
+                setValue: (value) => this.setLevelState(value),
             });
         }
-        if (device.data.motionStatus !== undefined && device.data.motionSensorEnabled !== false) {
+        if (device.data.motionStatus !== undefined &&
+            device.data.motionSensorEnabled !== false) {
             this.registerCharacteristic({
-                characteristicType: _hap.hap.Characteristic.MotionDetected,
+                characteristicType: hap_1.hap.Characteristic.MotionDetected,
                 serviceType: MotionSensor,
-                getValue: (data)=>data.motionStatus === 'faulted'
+                getValue: (data) => data.motionStatus === 'faulted',
             });
             this.initSensorService(MotionSensor);
         }
     }
+    setOnState(on) {
+        (0, util_1.logInfo)(`Turning ${this.device.name} ${on ? 'On' : 'Off'}`);
+        const { beamDurationSeconds } = this.config, duration = beamDurationSeconds
+            ? Math.min(beamDurationSeconds, 32767)
+            : undefined;
+        if (this.isLightGroup && this.groupId) {
+            return this.device.location.setLightGroup(this.groupId, on, duration);
+        }
+        const data = on ? { lightMode: 'on', duration } : { lightMode: 'default' };
+        return this.device.sendCommand('light-mode.set', data);
+    }
+    setLevelState(level) {
+        (0, util_1.logInfo)(`Setting brightness of ${this.device.name} to ${level}%`);
+        return this.device.setInfo({
+            device: { v1: { level: level / 100 } },
+        });
+    }
 }
+exports.Beam = Beam;

package/lib/brightness-only.js

@@ -1,36 +1,22 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "BrightnessOnly", {
-    enumerable: true,
-    get: ()=>BrightnessOnly
-});
-const _baseDeviceAccessory = require("./base-device-accessory");
-const _hap = require("./hap");
-const _util = require("ring-client-api/util");
-class BrightnessOnly extends _baseDeviceAccessory.BaseDeviceAccessory {
-    setLevelState(brightness) {
-        (0, _util.logInfo)(`Setting brightness of ${this.device.name} to ${brightness}%`);
-        return this.device.setInfo({
-            device: {
-                v1: {
-                    brightness: brightness / 100
-                }
-            }
-        });
-    }
-    constructor(device, accessory, config){
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrightnessOnly = void 0;
+const base_device_accessory_1 = require("./base-device-accessory");
+const hap_1 = require("./hap");
+const util_1 = require("ring-client-api/util");
+class BrightnessOnly extends base_device_accessory_1.BaseDeviceAccessory {
+    constructor(device, accessory, config) {
         super();
         this.device = device;
         this.accessory = accessory;
         this.config = config;
-        const { Characteristic , Service  } = _hap.hap, { context  } = accessory;
-        if (device.data.brightness !== undefined && !isNaN(device.data.brightness)) {
+        const { Characteristic, Service } = hap_1.hap, { context } = accessory;
+        if (device.data.brightness !== undefined &&
+            !isNaN(device.data.brightness)) {
             this.registerLevelCharacteristic({
                 characteristicType: Characteristic.Brightness,
                 serviceType: Service.Lightbulb,
-                getValue: (data)=>{
+                getValue: (data) => {
                     if (!data.brightness || isNaN(data.brightness)) {
                         return 0;
                     }
@@ -38,23 +24,30 @@ class BrightnessOnly extends _baseDeviceAccessory.BaseDeviceAccessory {
                     context.brightness = data.brightness * 100;
                     return context.brightness;
                 },
-                setValue: (brightness)=>{
+                setValue: (brightness) => {
                     if (brightness) {
                         context.brightness = brightness;
                     }
                     return this.setLevelState(brightness);
-                }
+                },
             });
             this.registerCharacteristic({
                 characteristicType: Characteristic.On,
                 serviceType: Service.Lightbulb,
-                getValue: (data)=>Boolean(data.brightness),
-                setValue: (on)=>{
+                getValue: (data) => Boolean(data.brightness),
+                setValue: (on) => {
                     const brightness = context.brightness || 100;
                     return this.setLevelState(on ? brightness : 0);
-                }
+                },
             });
             this.getService(Service.Lightbulb).setPrimaryService(true);
         }
     }
+    setLevelState(brightness) {
+        (0, util_1.logInfo)(`Setting brightness of ${this.device.name} to ${brightness}%`);
+        return this.device.setInfo({
+            device: { v1: { brightness: brightness / 100 } },
+        });
+    }
 }
+exports.BrightnessOnly = BrightnessOnly;