homebridge-tydom 0.21.9

package/lib/accessories/switch.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateSwitch = exports.setupSwitch = void 0;
+const hap_1 = require("../utils/hap");
+const accessory_1 = require("../utils/accessory");
+const switchableService_1 = require("./services/switchableService");
+const setupSwitch = (accessory, controller) => {
+    accessory_1.setupAccessoryInformationService(accessory, controller);
+    accessory_1.setupAccessoryIdentifyHandler(accessory, controller);
+    // Add the actual accessory Service
+    switchableService_1.addAccessorySwitchableService(accessory, controller, hap_1.Service.Switch);
+};
+exports.setupSwitch = setupSwitch;
+const updateSwitch = (accessory, controller, updates) => {
+    switchableService_1.updateAccessorySwitchableService(accessory, controller, updates, hap_1.Service.Switch);
+};
+exports.updateSwitch = updateSwitch;

package/lib/accessories/temperatureSensor.d.ts

@@ -0,0 +1,4 @@
+import type { PlatformAccessory } from 'homebridge';
+import TydomController from '../controller';
+export declare const setupTemperatureSensor: (accessory: PlatformAccessory, controller: TydomController) => void;
+export declare const updateTemperatureSensor: (accessory: PlatformAccessory, _controller: TydomController, updates: Record<string, unknown>[]) => void;

package/lib/accessories/temperatureSensor.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateTemperatureSensor = exports.setupTemperatureSensor = void 0;
+const accessory_1 = require("../utils/accessory");
+const debug_1 = require("../utils/debug");
+const hap_1 = require("../utils/hap");
+const tydom_1 = require("../utils/tydom");
+const setupTemperatureSensor = (accessory, controller) => {
+    const { context } = accessory;
+    const { client } = controller;
+    const { CurrentTemperature } = hap_1.Characteristic;
+    const { deviceId, endpointId } = context;
+    accessory_1.setupAccessoryInformationService(accessory, controller);
+    accessory_1.setupAccessoryIdentifyHandler(accessory, controller);
+    // Add the actual accessory Service
+    const service = accessory_1.addAccessoryService(accessory, hap_1.Service.TemperatureSensor, `${accessory.displayName}`, true);
+    service
+        .getCharacteristic(CurrentTemperature)
+        .setProps({
+        minValue: -100
+    })
+        .on("get" /* GET */, async (callback) => {
+        debug_1.debugGet(CurrentTemperature, service);
+        try {
+            const data = await tydom_1.getTydomDeviceData(client, { deviceId, endpointId });
+            const outTemperature = tydom_1.getTydomDataPropValue(data, 'outTemperature');
+            debug_1.debugGetResult(CurrentTemperature, service, outTemperature);
+            callback(null, outTemperature);
+        }
+        catch (err) {
+            callback(err);
+        }
+    });
+};
+exports.setupTemperatureSensor = setupTemperatureSensor;
+const updateTemperatureSensor = (accessory, _controller, updates) => {
+    updates.forEach((update) => {
+        const { name, value } = update;
+        const { CurrentTemperature } = hap_1.Characteristic;
+        switch (name) {
+            case 'outTemperature': {
+                const service = accessory_1.getAccessoryService(accessory, hap_1.Service.TemperatureSensor);
+                debug_1.debugSetUpdate(CurrentTemperature, service, value);
+                service.updateCharacteristic(CurrentTemperature, value);
+                return;
+            }
+            default:
+                return;
+        }
+    });
+};
+exports.updateTemperatureSensor = updateTemperatureSensor;

package/lib/accessories/thermostat.d.ts

@@ -0,0 +1,4 @@
+import type { PlatformAccessory } from 'homebridge';
+import TydomController from '../controller';
+export declare const setupThermostat: (accessory: PlatformAccessory, controller: TydomController) => void;
+export declare const updateThermostat: (accessory: PlatformAccessory, _controller: TydomController, updates: Record<string, unknown>[]) => void;

package/lib/accessories/thermostat.js

@@ -0,0 +1,340 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __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 });
+exports.updateThermostat = exports.setupThermostat = void 0;
+const lodash_1 = require("lodash");
+const locale_1 = __importDefault(require("../config/locale"));
+const accessory_1 = require("../utils/accessory");
+const chalk_1 = require("../utils/chalk");
+const debug_1 = __importStar(require("../utils/debug"));
+const hap_1 = require("../utils/hap");
+const tydom_1 = require("../utils/tydom");
+const setupThermostat = (accessory, controller) => {
+    const { context } = accessory;
+    const { client } = controller;
+    const { TargetHeatingCoolingState, CurrentHeatingCoolingState, TargetTemperature, CurrentTemperature, On } = hap_1.Characteristic;
+    const { deviceId, endpointId, metadata } = context;
+    accessory_1.setupAccessoryInformationService(accessory, controller);
+    accessory_1.setupAccessoryIdentifyHandler(accessory, controller);
+    // Add the actual accessory Service
+    const service = accessory_1.addAccessoryService(accessory, hap_1.Service.Thermostat, `${accessory.displayName}`, true);
+    service
+        .getCharacteristic(CurrentHeatingCoolingState)
+        .setProps({ validValues: [0, 1] }) // [OFF, HEAT, COOL]
+        .on("get" /* GET */, async (callback) => {
+        debug_1.debugGet(CurrentHeatingCoolingState, service);
+        try {
+            const data = await tydom_1.getTydomDeviceData(client, { deviceId, endpointId });
+            const authorization = tydom_1.getTydomDataPropValue(data, 'authorization');
+            const setpoint = tydom_1.getTydomDataPropValue(data, 'setpoint');
+            const temperature = tydom_1.getTydomDataPropValue(data, 'temperature');
+            const nextValue = authorization === 'HEATING' && setpoint > temperature
+                ? CurrentHeatingCoolingState.HEAT
+                : CurrentHeatingCoolingState.OFF;
+            debug_1.debugGetResult(CurrentHeatingCoolingState, service, nextValue);
+            callback(null, nextValue);
+        }
+        catch (err) {
+            callback(err);
+        }
+    })
+        .getValue();
+    service
+        .getCharacteristic(TargetHeatingCoolingState)
+        .setProps({ validValues: [0, 1] }) // [OFF, HEAT, COOL, AUTO]
+        .on("get" /* GET */, async (callback) => {
+        debug_1.debugGet(TargetHeatingCoolingState, service);
+        try {
+            const data = await tydom_1.getTydomDeviceData(client, { deviceId, endpointId });
+            const hvacMode = tydom_1.getTydomDataPropValue(data, 'hvacMode');
+            const authorization = tydom_1.getTydomDataPropValue(data, 'authorization');
+            const nextValue = authorization === 'HEATING' && ['NORMAL'].includes(hvacMode)
+                ? TargetHeatingCoolingState.HEAT
+                : TargetHeatingCoolingState.OFF;
+            debug_1.debugGetResult(TargetHeatingCoolingState, service, nextValue);
+            callback(null, nextValue);
+        }
+        catch (err) {
+            callback(err);
+        }
+    })
+        .on("set" /* SET */, async (value, callback) => {
+        debug_1.debugSet(TargetHeatingCoolingState, service, value);
+        try {
+            const shouldHeat = [TargetHeatingCoolingState.HEAT, TargetHeatingCoolingState.AUTO].includes(value);
+            const tydomValue = shouldHeat ? 'NORMAL' : 'STOP';
+            await client.put(`/devices/${deviceId}/endpoints/${endpointId}/data`, [
+                {
+                    name: 'hvacMode',
+                    value: tydomValue
+                }
+            ]);
+            debug_1.debugSetResult(TargetHeatingCoolingState, service, value, tydomValue);
+            // @NOTE directly update currentHeadingCoolingState
+            service
+                .getCharacteristic(CurrentHeatingCoolingState)
+                .updateValue(shouldHeat ? CurrentHeatingCoolingState.HEAT : CurrentHeatingCoolingState.OFF);
+            callback();
+        }
+        catch (err) {
+            callback(err);
+        }
+    });
+    service
+        .getCharacteristic(CurrentTemperature)
+        .on("get" /* GET */, async (callback) => {
+        debug_1.debugGet(CurrentTemperature, service);
+        try {
+            const data = await tydom_1.getTydomDeviceData(client, { deviceId, endpointId });
+            const temperature = tydom_1.getTydomDataPropValue(data, 'temperature');
+            debug_1.debugGetResult(CurrentTemperature, service, temperature);
+            callback(null, temperature);
+        }
+        catch (err) {
+            callback(err);
+        }
+    })
+        .getValue();
+    service
+        .getCharacteristic(TargetTemperature)
+        .on("get" /* GET */, async (callback) => {
+        debug_1.debugGet(TargetTemperature, service);
+        try {
+            const data = await tydom_1.getTydomDeviceData(client, { deviceId, endpointId });
+            const setpoint = tydom_1.getTydomDataPropValue(data, 'setpoint');
+            debug_1.debugGetResult(TargetTemperature, service, setpoint);
+            callback(null, setpoint);
+        }
+        catch (err) {
+            callback(err);
+        }
+    })
+        .on("set" /* SET */, async (value, callback) => {
+        try {
+            debug_1.debugSet(TargetTemperature, service, value);
+            await client.put(`/devices/${deviceId}/endpoints/${endpointId}/data`, [
+                {
+                    name: 'setpoint',
+                    value: value
+                }
+            ]);
+            debug_1.debugSetResult(TargetTemperature, service, value);
+            callback();
+        }
+        catch (err) {
+            callback(err);
+        }
+    });
+    const thermicLevelData = metadata.find(({ name }) => name === 'thermicLevel');
+    if (!thermicLevelData) {
+        controller.log.error(`Failed to properly create the thermostat accesory for device ${deviceId}, did not found object in array that matches {"name": "thermicLevel"} in ${JSON.stringify(metadata)}`);
+        return;
+    }
+    const thermicLevelValues = thermicLevelData.enum_values;
+    // Only absence (aka. anti-frost) mode
+    if (thermicLevelValues.length === 1) {
+        const absenceModeId = `hvacMode_absence`;
+        const absenceModeName = lodash_1.get(locale_1.default, 'HVAC_INFO_ABSENCE', 'N/A');
+        const absenceModeService = accessory_1.addAccessoryServiceWithSubtype(accessory, hap_1.Service.Switch, absenceModeName, absenceModeId, true);
+        debug_1.debugAddSubService(absenceModeService, accessory);
+        service.addLinkedService(absenceModeService);
+        absenceModeService
+            .getCharacteristic(On)
+            .on("get" /* GET */, async (callback) => {
+            debug_1.debugGet(On, absenceModeService);
+            try {
+                const data = await tydom_1.getTydomDeviceData(client, { deviceId, endpointId });
+                const hvacMode = tydom_1.getTydomDataPropValue(data, 'hvacMode');
+                // const antifrostOn = getTydomDataPropValue<boolean>(data, 'antifrostOn');
+                // const nextValue = hvacMode === 'ANTI_FROST' && antifrostOn;
+                const nextValue = hvacMode === 'ANTI_FROST';
+                debug_1.debugGetResult(On, absenceModeService, nextValue);
+                callback(null, nextValue);
+            }
+            catch (err) {
+                callback(err);
+            }
+        })
+            .on("set" /* SET */, async (value, callback) => {
+            debug_1.debugSet(On, absenceModeService, value);
+            try {
+                const tydomValue = value ? 'ANTI_FROST' : 'NORMAL';
+                await client.put(`/devices/${deviceId}/endpoints/${endpointId}/data`, [
+                    {
+                        name: 'hvacMode',
+                        value: tydomValue
+                    }
+                ]);
+                debug_1.debugSetResult(On, absenceModeService, value, tydomValue);
+                callback();
+            }
+            catch (err) {
+                callback(err);
+            }
+        });
+    }
+    // Multiple thermic levels
+    // "enum_values": ["ECO", "MODERATO", "MEDIO", "COMFORT", "STOP", "ANTI_FROST"]
+    if (thermicLevelValues.length > 1) {
+        const THERMIC_LEVELS_WHITELIST = ['ANTI_FROST', 'ECO', 'COMFORT'];
+        const thermicLevelServices = thermicLevelValues
+            .filter((value) => THERMIC_LEVELS_WHITELIST.includes(value))
+            .map((thermicLevelValue) => {
+            const thermicLevelId = `thermicLevel_${thermicLevelValue.toLowerCase()}`;
+            const thermicLevelName = lodash_1.get(locale_1.default, `HVAC_LEVEL_${thermicLevelValue}`, 'N/A');
+            const thermicLevelService = accessory_1.addAccessoryServiceWithSubtype(accessory, hap_1.Service.Switch, thermicLevelName, thermicLevelId, true);
+            debug_1.debugAddSubService(thermicLevelService, accessory);
+            service.addLinkedService(thermicLevelService);
+            thermicLevelService
+                .getCharacteristic(On)
+                .on("get" /* GET */, async (callback) => {
+                debug_1.debugGet(On, thermicLevelService);
+                try {
+                    const data = await tydom_1.getTydomDeviceData(client, { deviceId, endpointId });
+                    const thermicLevel = tydom_1.getTydomDataPropValue(data, 'thermicLevel');
+                    const nextValue = thermicLevel === thermicLevelValue;
+                    debug_1.debugGetResult(On, thermicLevelService, nextValue);
+                    callback(null, nextValue);
+                }
+                catch (err) {
+                    callback(err);
+                }
+            })
+                .on("set" /* SET */, async (value, callback) => {
+                debug_1.debugSet(On, thermicLevelService, value);
+                try {
+                    const tydomValue = value ? thermicLevelValue : 'NORMAL';
+                    await client.put(`/devices/${deviceId}/endpoints/${endpointId}/data`, [
+                        {
+                            name: 'hvacMode',
+                            value: tydomValue
+                        }
+                    ]);
+                    debug_1.debugSetResult(On, thermicLevelService, tydomValue);
+                    callback();
+                    // @NOTE disable any other existing thermicLevel
+                    thermicLevelServices
+                        .filter(({ value }) => value !== thermicLevelValue)
+                        .forEach(({ service }) => {
+                        service.updateCharacteristic(On, false);
+                    });
+                }
+                catch (err) {
+                    callback(err);
+                }
+            });
+            return { value: thermicLevelValue, service: thermicLevelService };
+        });
+    }
+};
+exports.setupThermostat = setupThermostat;
+const updateThermostat = (accessory, _controller, updates) => {
+    const { TargetHeatingCoolingState, CurrentHeatingCoolingState, TargetTemperature, CurrentTemperature, On } = hap_1.Characteristic;
+    updates.forEach((update) => {
+        const { name, value } = update;
+        switch (name) {
+            case 'authorization': {
+                const service = accessory_1.getAccessoryService(accessory, hap_1.Service.Thermostat);
+                const authorization = value;
+                if (authorization === 'HEATING') {
+                    // @TODO Trigger a get as we miss info
+                    return;
+                }
+                if (authorization === 'STOP') {
+                    debug_1.debugSetUpdate(CurrentHeatingCoolingState, service, CurrentHeatingCoolingState.OFF);
+                    service.updateCharacteristic(CurrentHeatingCoolingState, CurrentHeatingCoolingState.OFF);
+                    // External update probably comes from the Tydom app, let's agree on the target state
+                    debug_1.debugSetUpdate(TargetHeatingCoolingState, service, TargetHeatingCoolingState.OFF);
+                    service.updateCharacteristic(TargetHeatingCoolingState, TargetHeatingCoolingState.OFF);
+                    return;
+                }
+                return;
+            }
+            case 'hvacMode': {
+                const service = accessory_1.getAccessoryService(accessory, hap_1.Service.Thermostat);
+                const hvacMode = value;
+                if (hvacMode === 'NORMAL') {
+                    // @TODO Trigger a get as we miss info
+                    return;
+                }
+                service.updateCharacteristic(TargetHeatingCoolingState, CurrentHeatingCoolingState.OFF);
+                if (hvacMode === 'ANTI_FROST') {
+                    const subtype = 'hvacMode_absence';
+                    const service = accessory.getServiceByUUIDAndSubType(hap_1.Service.Switch, subtype);
+                    if (service) {
+                        debug_1.debugSetUpdate(On, service, true);
+                        service.updateCharacteristic(On, true);
+                        return;
+                    }
+                }
+                return;
+            }
+            case 'thermicLevel': {
+                const thermicLevel = value;
+                if (thermicLevel === null) {
+                    debug_1.default(`Encountered a ${chalk_1.chalkString('thermicLevel')} update with a null value!`);
+                    return;
+                }
+                const service = accessory.getServiceByUUIDAndSubType(hap_1.Service.Switch, `thermicLevel_${thermicLevel.toLowerCase()}`);
+                if (service) {
+                    debug_1.debugSetUpdate(On, service, true);
+                    service.updateCharacteristic(On, true);
+                    return;
+                }
+                return;
+            }
+            // case 'antifrostOn': {
+            //   const subtype = 'antifrostOn';
+            //   const service = accessory.getServiceByUUIDAndSubType(Service.Switch, subtype);
+            //   assert(service, `Unexpected missing service "Service.Switch" with subtype="${subtype}" in accessory`);
+            //   const antifrostOn = value as boolean;
+            //   service.updateCharacteristic(Characteristic, antifrostOn);
+            //   return;
+            // }
+            case 'setpoint': {
+                const setpoint = value;
+                if (setpoint === null) {
+                    debug_1.default(`Encountered a ${chalk_1.chalkString('setpoint')} update with a null value!`);
+                    return;
+                }
+                const service = accessory_1.getAccessoryService(accessory, hap_1.Service.Thermostat);
+                debug_1.debugSetUpdate(TargetTemperature, service, setpoint);
+                service.updateCharacteristic(TargetTemperature, setpoint);
+                return;
+            }
+            case 'temperature': {
+                const service = accessory_1.getAccessoryService(accessory, hap_1.Service.Thermostat);
+                debug_1.debugSetUpdate(CurrentTemperature, service, value);
+                service.updateCharacteristic(CurrentTemperature, value);
+                return;
+            }
+            default:
+                return;
+        }
+    });
+};
+exports.updateThermostat = updateThermostat;
+// OFF -> authorization === STOP
+// ANTI_FROST -> hvacMode === ANTI_FROST
+// CHAUFFAGE -> authorization === HEATING

package/lib/accessories/windowCovering.d.ts

@@ -0,0 +1,5 @@
+import type { PlatformAccessory } from 'homebridge';
+import TydomController from '../controller';
+import { TydomAccessoryUpdateType } from '../utils/accessory';
+export declare const setupWindowCovering: (accessory: PlatformAccessory, controller: TydomController) => void;
+export declare const updateWindowCovering: (accessory: PlatformAccessory, _controller: TydomController, updates: Record<string, unknown>[], type: TydomAccessoryUpdateType) => void;

package/lib/accessories/windowCovering.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateWindowCovering = exports.setupWindowCovering = void 0;
+const lodash_1 = require("lodash");
+const accessory_1 = require("../utils/accessory");
+const chalk_1 = require("../utils/chalk");
+const debug_1 = require("../utils/debug");
+const hap_1 = require("../utils/hap");
+const tydom_1 = require("../utils/tydom");
+const setupWindowCovering = (accessory, controller) => {
+    const { context } = accessory;
+    const { client } = controller;
+    const { CurrentPosition, TargetPosition, PositionState, HoldPosition } = hap_1.Characteristic;
+    const { deviceId, endpointId, state } = context;
+    accessory_1.setupAccessoryInformationService(accessory, controller);
+    accessory_1.setupAccessoryIdentifyHandler(accessory, controller);
+    Object.assign(state, {
+        latestPosition: 100,
+        pendingUpdatedValues: [],
+        lastUpdatedAt: 0
+    });
+    // Add the actual accessory Service
+    const service = accessory_1.addAccessoryService(accessory, hap_1.Service.WindowCovering, `${accessory.displayName}`, true);
+    const debouncedSetPosition = lodash_1.debounce(async (value) => {
+        debug_1.debugTydomPut('position', accessory, value);
+        await client.put(`/devices/${deviceId}/endpoints/${endpointId}/data`, [
+            {
+                name: 'position',
+                value
+            }
+        ]);
+        Object.assign(state, {
+            pendingUpdatedValues: state.pendingUpdatedValues.concat([value])
+        });
+    }, 250, { leading: true, trailing: false });
+    service
+        .getCharacteristic(PositionState)
+        .on("get" /* GET */, async (callback) => {
+        debug_1.debugGet(PositionState, service);
+        try {
+            // @NOTE Tydom does not track the current position
+            const nextValue = PositionState.STOPPED;
+            debug_1.debugGetResult(CurrentPosition, service, nextValue);
+            callback(null, nextValue);
+        }
+        catch (err) {
+            callback(err);
+        }
+    })
+        .getValue();
+    service
+        .getCharacteristic(HoldPosition)
+        .on("set" /* SET */, async (value, callback) => {
+        debug_1.debugSet(HoldPosition, service, value);
+        if (!value) {
+            // @NOTE asked to not hold position
+            return;
+        }
+        const nextValue = 'STOP';
+        debug_1.debugTydomPut('positionCmd', accessory, nextValue);
+        await client.put(`/devices/${deviceId}/endpoints/${endpointId}/data`, [
+            {
+                name: 'positionCmd',
+                value: nextValue
+            }
+        ]);
+        debug_1.debugSetResult(HoldPosition, service, value, nextValue);
+        callback();
+    })
+        .getValue();
+    service
+        .getCharacteristic(CurrentPosition)
+        .on("get" /* GET */, async (callback) => {
+        debug_1.debugGet(CurrentPosition, service);
+        try {
+            const data = await tydom_1.getTydomDeviceData(client, { deviceId, endpointId });
+            const position = tydom_1.getTydomDataPropValue(data, 'position') || 0;
+            const nextValue = accessory_1.asNumber(position);
+            debug_1.debugGetResult(CurrentPosition, service, nextValue);
+            callback(null, nextValue);
+        }
+        catch (err) {
+            callback(err);
+        }
+    })
+        .getValue();
+    service
+        .getCharacteristic(TargetPosition)
+        .on("get" /* GET */, async (callback) => {
+        debug_1.debugGet(TargetPosition, service);
+        try {
+            const data = await tydom_1.getTydomDeviceData(client, { deviceId, endpointId });
+            const position = tydom_1.getTydomDataPropValue(data, 'position') || 0;
+            const nextValue = accessory_1.asNumber(position);
+            debug_1.debugGetResult(CurrentPosition, service, nextValue);
+            callback(null, nextValue);
+        }
+        catch (err) {
+            callback(err);
+        }
+    })
+        .on("set" /* SET */, async (value, callback) => {
+        debug_1.debugSet(TargetPosition, service, value);
+        try {
+            const nextValue = value;
+            Object.assign(state, {
+                latestPosition: nextValue,
+                lastUpdatedAt: Date.now()
+            });
+            await debouncedSetPosition(nextValue);
+            debug_1.debugSetResult(TargetPosition, service, value, nextValue);
+            callback();
+        }
+        catch (err) {
+            callback(err);
+        }
+    })
+        .getValue();
+};
+exports.setupWindowCovering = setupWindowCovering;
+const updateWindowCovering = (accessory, _controller, updates, type) => {
+    const { context } = accessory;
+    const { state } = context;
+    const { CurrentPosition, TargetPosition, ObstructionDetected } = hap_1.Characteristic;
+    // Process command updates
+    if (type === 'cdata') {
+        updates.forEach((update) => {
+            const { values } = update;
+            const { event } = values;
+            debug_1.debug(`New ${chalk_1.chalkKeyword('WindowCovering')} event=${chalk_1.chalkJson(event)}`);
+        });
+        return;
+    }
+    updates.forEach((update) => {
+        const { name, value } = update;
+        switch (name) {
+            case 'position': {
+                const service = accessory_1.getAccessoryService(accessory, hap_1.Service.WindowCovering);
+                const position = accessory_1.asNumber(value);
+                if (position === null) {
+                    debug_1.debug(`Encountered a ${chalk_1.chalkString('position')} update with a null value!`);
+                    return;
+                }
+                debug_1.debugSetUpdate(CurrentPosition, service, position);
+                service.updateCharacteristic(CurrentPosition, position);
+                // @NOTE ignore pending updates
+                if (state.pendingUpdatedValues.includes(position)) {
+                    debug_1.debug(`Ignoring a pending ${chalk_1.chalkString('position')} update with value=${chalk_1.chalkNumber(position)} !`);
+                    state.pendingUpdatedValues = [];
+                    return;
+                }
+                debug_1.debugSetUpdate(TargetPosition, service, position);
+                service.updateCharacteristic(TargetPosition, position);
+                return;
+            }
+            case 'obstacleDefect': {
+                const service = accessory_1.getAccessoryService(accessory, hap_1.Service.WindowCovering);
+                debug_1.debugSetUpdate(ObstructionDetected, service, value);
+                service.updateCharacteristic(ObstructionDetected, value);
+                return;
+            }
+            default:
+                return;
+        }
+    });
+};
+exports.updateWindowCovering = updateWindowCovering;

package/lib/config/env.d.ts

@@ -0,0 +1,3 @@
+export declare const PLUGIN_NAME = "homebridge-tydom";
+export declare const PLATFORM_NAME = "Tydom";
+export declare const DEBUG: string | undefined, HOMEBRIDGE_TYDOM_PASSWORD: string | undefined, HOMEBRIDGE_TYDOM_PIN: string | undefined, HOMEBRIDGE_TYDOM_LOCALE: string;

package/lib/config/env.js

@@ -0,0 +1,7 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HOMEBRIDGE_TYDOM_LOCALE = exports.HOMEBRIDGE_TYDOM_PIN = exports.HOMEBRIDGE_TYDOM_PASSWORD = exports.DEBUG = exports.PLATFORM_NAME = exports.PLUGIN_NAME = void 0;
+exports.PLUGIN_NAME = 'homebridge-tydom';
+exports.PLATFORM_NAME = 'Tydom';
+_a = process.env, exports.DEBUG = _a.DEBUG, exports.HOMEBRIDGE_TYDOM_PASSWORD = _a.HOMEBRIDGE_TYDOM_PASSWORD, exports.HOMEBRIDGE_TYDOM_PIN = _a.HOMEBRIDGE_TYDOM_PIN, _b = _a.HOMEBRIDGE_TYDOM_LOCALE, exports.HOMEBRIDGE_TYDOM_LOCALE = _b === void 0 ? 'fr' : _b;