homebridge-tuya-without-developer-account 1.0.0

package/dist/shared/accessories/ExtractionHoodAccessory.js

@@ -0,0 +1,120 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const TuyaDevice_1 = require("../../cloud/device/TuyaDevice");
+const BaseAccessory_1 = __importDefault(require("./BaseAccessory"));
+const Active_1 = require("./characteristic/Active");
+const LockPhysicalControls_1 = require("./characteristic/LockPhysicalControls");
+const RotationSpeed_1 = require("./characteristic/RotationSpeed");
+const Light_1 = require("./characteristic/Light");
+const On_1 = require("./characteristic/On");
+const SCHEMA_CODE = {
+    ACTIVE: ['switch'],
+    MODE: ['mode'],
+    LOCK: ['lock'],
+    SPEED: ['speed'],
+    SPEED_LEVEL: ['fan_speed_enum', 'speed'],
+    AIR_QUALITY: ['air_quality', 'pm25'],
+    PM2_5: ['pm25'],
+    VOC: ['tvoc'],
+    LIGHT_ON: ['light', 'switch_led'],
+    LIGHT_MODE: ['work_mode'],
+    LIGHT_BRIGHT: ['bright_value', 'bright_value_v2'],
+    LIGHT_TEMP: ['temp_value', 'temp_value_v2'],
+    LIGHT_COLOR: ['colour_data'],
+};
+class ExtractionHoodAccessory extends BaseAccessory_1.default {
+    requiredSchema() {
+        return [SCHEMA_CODE.ACTIVE];
+    }
+    configureServices() {
+        (0, Active_1.configureActive)(this, this.mainService(), this.getSchema(...SCHEMA_CODE.ACTIVE));
+        this.configureCurrentState();
+        this.configureTargetState();
+        (0, LockPhysicalControls_1.configureLockPhysicalControls)(this, this.mainService(), this.getSchema(...SCHEMA_CODE.LOCK));
+        if (this.getFanSpeedSchema()) {
+            (0, RotationSpeed_1.configureRotationSpeed)(this, this.mainService(), this.getFanSpeedSchema());
+        }
+        else if (this.getFanSpeedLevelSchema()) {
+            (0, RotationSpeed_1.configureRotationSpeedLevel)(this, this.mainService(), this.getFanSpeedLevelSchema());
+        }
+        // Light
+        if (this.getSchema(...SCHEMA_CODE.LIGHT_ON)) {
+            if (this.lightServiceType() === this.Service.Lightbulb) {
+                (0, Light_1.configureLight)(this, this.lightService(), this.getSchema(...SCHEMA_CODE.LIGHT_ON), this.getSchema(...SCHEMA_CODE.LIGHT_BRIGHT), this.getSchema(...SCHEMA_CODE.LIGHT_TEMP), this.getSchema(...SCHEMA_CODE.LIGHT_COLOR), this.getSchema(...SCHEMA_CODE.LIGHT_MODE));
+            }
+            else if (this.lightServiceType() === this.Service.Switch) {
+                (0, On_1.configureOn)(this, undefined, this.getSchema(...SCHEMA_CODE.LIGHT_ON));
+                const unusedService = this.accessory.getService(this.Service.Lightbulb);
+                if (unusedService) {
+                    this.accessory.removeService(unusedService);
+                }
+            }
+        }
+    }
+    mainService() {
+        return this.accessory.getService(this.Service.AirPurifier)
+            || this.accessory.addService(this.Service.AirPurifier);
+    }
+    getFanSpeedSchema() {
+        const schema = this.getSchema(...SCHEMA_CODE.SPEED);
+        if (schema && schema.type === TuyaDevice_1.TuyaDeviceSchemaType.Integer) {
+            return schema;
+        }
+        return undefined;
+    }
+    getFanSpeedLevelSchema() {
+        const schema = this.getSchema(...SCHEMA_CODE.SPEED_LEVEL);
+        if (schema && schema.type === TuyaDevice_1.TuyaDeviceSchemaType.Enum) {
+            return schema;
+        }
+        return undefined;
+    }
+    configureCurrentState() {
+        const schema = this.getSchema(...SCHEMA_CODE.ACTIVE);
+        if (!schema) {
+            return;
+        }
+        const { INACTIVE, PURIFYING_AIR } = this.Characteristic.CurrentAirPurifierState;
+        this.mainService().getCharacteristic(this.Characteristic.CurrentAirPurifierState)
+            .onGet(() => {
+            const status = this.getStatus(schema.code);
+            return status.value ? PURIFYING_AIR : INACTIVE;
+        });
+    }
+    configureTargetState() {
+        const schema = this.getSchema(...SCHEMA_CODE.MODE);
+        if (!schema) {
+            return;
+        }
+        const { MANUAL, AUTO } = this.Characteristic.TargetAirPurifierState;
+        this.mainService().getCharacteristic(this.Characteristic.TargetAirPurifierState)
+            .onGet(() => {
+            const status = this.getStatus(schema.code);
+            return (status.value === 'auto') ? AUTO : MANUAL;
+        })
+            .onSet(async (value) => {
+            await this.sendCommands([{
+                    code: schema.code,
+                    value: (value === AUTO) ? 'auto' : 'manual',
+                }], true);
+        });
+    }
+    lightServiceType() {
+        if (this.getSchema(...SCHEMA_CODE.LIGHT_BRIGHT)
+            || this.getSchema(...SCHEMA_CODE.LIGHT_TEMP)
+            || this.getSchema(...SCHEMA_CODE.LIGHT_COLOR)
+            || this.getSchema(...SCHEMA_CODE.LIGHT_MODE)) {
+            return this.Service.Lightbulb;
+        }
+        return this.Service.Switch;
+    }
+    lightService() {
+        return this.accessory.getService(this.Service.Lightbulb)
+            || this.accessory.addService(this.Service.Lightbulb);
+    }
+}
+exports.default = ExtractionHoodAccessory;
+//# sourceMappingURL=ExtractionHoodAccessory.js.map

package/dist/shared/accessories/FanAccessory.js

@@ -0,0 +1,129 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const TuyaDevice_1 = require("../../cloud/device/TuyaDevice");
+const BaseAccessory_1 = __importDefault(require("./BaseAccessory"));
+const Active_1 = require("./characteristic/Active");
+const Light_1 = require("./characteristic/Light");
+const LockPhysicalControls_1 = require("./characteristic/LockPhysicalControls");
+const On_1 = require("./characteristic/On");
+const RotationSpeed_1 = require("./characteristic/RotationSpeed");
+const SwingMode_1 = require("./characteristic/SwingMode");
+const SCHEMA_CODE = {
+    FAN_ON: ['switch_fan', 'fan_switch', 'switch'],
+    FAN_DIRECTION: ['fan_direction'],
+    FAN_SPEED: ['fan_speed', 'fan_speed_percent'],
+    FAN_SPEED_LEVEL: ['fan_speed_enum', 'fan_speed'],
+    FAN_LOCK: ['child_lock'],
+    FAN_SWING: ['switch_horizontal', 'switch_vertical'],
+    LIGHT_ON: ['light', 'switch_led'],
+    LIGHT_MODE: ['work_mode'],
+    LIGHT_BRIGHT: ['bright_value', 'bright_value_v2'],
+    LIGHT_TEMP: ['temp_value', 'temp_value_v2'],
+    LIGHT_COLOR: ['colour_data'],
+};
+class FanAccessory extends BaseAccessory_1.default {
+    requiredSchema() {
+        return [SCHEMA_CODE.FAN_ON];
+    }
+    configureServices() {
+        if (this.fanServiceType() === this.Service.Fan) {
+            const unusedService = this.accessory.getService(this.Service.Fanv2);
+            if (unusedService) {
+                this.accessory.removeService(unusedService);
+            }
+            (0, On_1.configureOn)(this, this.fanService(), this.getSchema(...SCHEMA_CODE.FAN_ON));
+        }
+        else if (this.fanServiceType() === this.Service.Fanv2) {
+            const unusedService = this.accessory.getService(this.Service.Fan);
+            if (unusedService) {
+                this.accessory.removeService(unusedService);
+            }
+            (0, Active_1.configureActive)(this, this.fanService(), this.getSchema(...SCHEMA_CODE.FAN_ON));
+            (0, LockPhysicalControls_1.configureLockPhysicalControls)(this, this.fanService(), this.getSchema(...SCHEMA_CODE.FAN_LOCK));
+            (0, SwingMode_1.configureSwingMode)(this, this.fanService(), this.getSchema(...SCHEMA_CODE.FAN_SWING));
+        }
+        // Common Characteristics
+        if (this.getFanSpeedSchema()) {
+            (0, RotationSpeed_1.configureRotationSpeed)(this, this.fanService(), this.getFanSpeedSchema());
+        }
+        else if (this.getFanSpeedLevelSchema()) {
+            (0, RotationSpeed_1.configureRotationSpeedLevel)(this, this.fanService(), this.getFanSpeedLevelSchema());
+        }
+        else {
+            (0, RotationSpeed_1.configureRotationSpeedOn)(this, this.fanService(), this.getSchema(...SCHEMA_CODE.FAN_ON));
+        }
+        this.configureRotationDirection();
+        // Light
+        if (this.getSchema(...SCHEMA_CODE.LIGHT_ON)) {
+            if (this.lightServiceType() === this.Service.Lightbulb) {
+                (0, Light_1.configureLight)(this, this.lightService(), this.getSchema(...SCHEMA_CODE.LIGHT_ON), this.getSchema(...SCHEMA_CODE.LIGHT_BRIGHT), this.getSchema(...SCHEMA_CODE.LIGHT_TEMP), this.getSchema(...SCHEMA_CODE.LIGHT_COLOR), this.getSchema(...SCHEMA_CODE.LIGHT_MODE));
+            }
+            else if (this.lightServiceType() === this.Service.Switch) {
+                (0, On_1.configureOn)(this, undefined, this.getSchema(...SCHEMA_CODE.LIGHT_ON));
+                const unusedService = this.accessory.getService(this.Service.Lightbulb);
+                if (unusedService) {
+                    this.accessory.removeService(unusedService);
+                }
+            }
+        }
+    }
+    fanServiceType() {
+        if (this.getSchema(...SCHEMA_CODE.FAN_LOCK)
+            || this.getSchema(...SCHEMA_CODE.FAN_SWING)) {
+            return this.Service.Fanv2;
+        }
+        return this.Service.Fan;
+    }
+    fanService() {
+        const serviceType = this.fanServiceType();
+        return this.accessory.getService(serviceType)
+            || this.accessory.addService(serviceType);
+    }
+    lightServiceType() {
+        if (this.getSchema(...SCHEMA_CODE.LIGHT_BRIGHT)
+            || this.getSchema(...SCHEMA_CODE.LIGHT_TEMP)
+            || this.getSchema(...SCHEMA_CODE.LIGHT_COLOR)
+            || this.getSchema(...SCHEMA_CODE.LIGHT_MODE)) {
+            return this.Service.Lightbulb;
+        }
+        return this.Service.Switch;
+    }
+    lightService() {
+        return this.accessory.getService(this.Service.Lightbulb)
+            || this.accessory.addService(this.Service.Lightbulb);
+    }
+    getFanSpeedSchema() {
+        const schema = this.getSchema(...SCHEMA_CODE.FAN_SPEED);
+        if (schema && schema.type === TuyaDevice_1.TuyaDeviceSchemaType.Integer) {
+            return schema;
+        }
+        return undefined;
+    }
+    getFanSpeedLevelSchema() {
+        const schema = this.getSchema(...SCHEMA_CODE.FAN_SPEED_LEVEL);
+        if (schema && schema.type === TuyaDevice_1.TuyaDeviceSchemaType.Enum) {
+            return schema;
+        }
+        return undefined;
+    }
+    configureRotationDirection() {
+        const schema = this.getSchema(...SCHEMA_CODE.FAN_DIRECTION);
+        if (!schema) {
+            return;
+        }
+        const { CLOCKWISE, COUNTER_CLOCKWISE } = this.Characteristic.RotationDirection;
+        this.fanService().getCharacteristic(this.Characteristic.RotationDirection)
+            .onGet(() => {
+            const status = this.getStatus(schema.code);
+            return (status.value !== 'reverse') ? CLOCKWISE : COUNTER_CLOCKWISE;
+        })
+            .onSet(async (value) => {
+            await this.sendCommands([{ code: schema.code, value: (value === CLOCKWISE) ? 'forward' : 'reverse' }]);
+        });
+    }
+}
+exports.default = FanAccessory;
+//# sourceMappingURL=FanAccessory.js.map

package/dist/shared/accessories/GarageDoorAccessory.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseAccessory_1 = __importDefault(require("./BaseAccessory"));
+const SCHEMA_CODE = {
+    CURRENT_DOOR_STATE: ['doorcontact_state'],
+    TARGET_DOOR_STATE: ['switch_1'],
+};
+class GarageDoorAccessory extends BaseAccessory_1.default {
+    requiredSchema() {
+        return [SCHEMA_CODE.TARGET_DOOR_STATE];
+    }
+    configureServices() {
+        this.configureCurrentDoorState();
+        this.configureTargetDoorState();
+    }
+    mainService() {
+        return this.accessory.getService(this.Service.GarageDoorOpener)
+            || this.accessory.addService(this.Service.GarageDoorOpener);
+    }
+    configureCurrentDoorState() {
+        const { OPEN, CLOSED, OPENING, CLOSING, STOPPED } = this.Characteristic.CurrentDoorState;
+        this.mainService().getCharacteristic(this.Characteristic.CurrentDoorState)
+            .onGet(() => {
+            const currentSchema = this.getSchema(...SCHEMA_CODE.CURRENT_DOOR_STATE);
+            const targetSchema = this.getSchema(...SCHEMA_CODE.TARGET_DOOR_STATE);
+            if (!currentSchema || !targetSchema) {
+                return STOPPED;
+            }
+            const currentStatus = this.getStatus(currentSchema.code);
+            const targetStatus = this.getStatus(targetSchema.code);
+            if (currentStatus.value === true && targetStatus.value === true) {
+                return OPEN;
+            }
+            else if (currentStatus.value === false && targetStatus.value === false) {
+                return CLOSED;
+            }
+            else if (currentStatus.value === false && targetStatus.value === true) {
+                return OPENING;
+            }
+            else if (currentStatus.value === true && targetStatus.value === false) {
+                return CLOSING;
+            }
+            return STOPPED;
+        });
+    }
+    configureTargetDoorState() {
+        const schema = this.getSchema(...SCHEMA_CODE.TARGET_DOOR_STATE);
+        if (!schema) {
+            return;
+        }
+        const { OPEN, CLOSED } = this.Characteristic.TargetDoorState;
+        this.mainService().getCharacteristic(this.Characteristic.TargetDoorState)
+            .onGet(() => {
+            const status = this.getStatus(schema.code);
+            return status.value ? OPEN : CLOSED;
+        })
+            .onSet(async (value) => {
+            await this.sendCommands([{
+                    code: schema.code,
+                    value: (value === OPEN) ? true : false,
+                }]);
+        });
+    }
+}
+exports.default = GarageDoorAccessory;
+//# sourceMappingURL=GarageDoorAccessory.js.map

package/dist/shared/accessories/HeaterAccessory.js

@@ -0,0 +1,102 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util/util");
+const BaseAccessory_1 = __importDefault(require("./BaseAccessory"));
+const Active_1 = require("./characteristic/Active");
+const CurrentTemperature_1 = require("./characteristic/CurrentTemperature");
+const LockPhysicalControls_1 = require("./characteristic/LockPhysicalControls");
+const SwingMode_1 = require("./characteristic/SwingMode");
+const TemperatureDisplayUnits_1 = require("./characteristic/TemperatureDisplayUnits");
+const SCHEMA_CODE = {
+    ACTIVE: ['switch'],
+    WORK_STATE: ['work_state', 'mode'],
+    CURRENT_TEMP: ['temp_current'],
+    TARGET_TEMP: ['temp_set'],
+    LOCK: ['lock'],
+    SWING: ['shake'],
+    TEMP_UNIT_CONVERT: ['temp_unit_convert', 'c_f'],
+};
+const STATE_CODE = {
+    HEATING: ['heating', 'High'],
+    IDLE: ['warming', 'Low'],
+};
+class HeaterAccessory extends BaseAccessory_1.default {
+    requiredSchema() {
+        return [SCHEMA_CODE.ACTIVE];
+    }
+    configureServices() {
+        (0, Active_1.configureActive)(this, this.mainService(), this.getSchema(...SCHEMA_CODE.ACTIVE));
+        this.configureCurrentState();
+        this.configureTargetState();
+        (0, CurrentTemperature_1.configureCurrentTemperature)(this, this.mainService(), this.getSchema(...SCHEMA_CODE.CURRENT_TEMP));
+        (0, LockPhysicalControls_1.configureLockPhysicalControls)(this, this.mainService(), this.getSchema(...SCHEMA_CODE.LOCK));
+        (0, SwingMode_1.configureSwingMode)(this, this.mainService(), this.getSchema(...SCHEMA_CODE.SWING));
+        this.configureHeatingThresholdTemp();
+        (0, TemperatureDisplayUnits_1.configureTempDisplayUnits)(this, this.mainService(), this.getSchema(...SCHEMA_CODE.TEMP_UNIT_CONVERT));
+    }
+    mainService() {
+        return this.accessory.getService(this.Service.HeaterCooler)
+            || this.accessory.addService(this.Service.HeaterCooler);
+    }
+    configureCurrentState() {
+        const schema = this.getSchema(...SCHEMA_CODE.WORK_STATE);
+        const { ACTIVE: ON, INACTIVE: OFF } = this.Characteristic.Active;
+        const { INACTIVE, IDLE, HEATING } = this.Characteristic.CurrentHeaterCoolerState;
+        this.mainService().getCharacteristic(this.Characteristic.CurrentHeaterCoolerState)
+            .onGet(() => {
+            if (!schema) {
+                return INACTIVE;
+            }
+            if (this.mainService().getCharacteristic(this.Characteristic.Active).value === OFF) {
+                return INACTIVE;
+            }
+            const status = this.getStatus(schema.code);
+            if (STATE_CODE.HEATING.includes(status.value)) {
+                return HEATING;
+            }
+            else if (STATE_CODE.IDLE.includes(status.value)) {
+                return IDLE;
+            }
+            return INACTIVE;
+        });
+    }
+    configureTargetState() {
+        const { AUTO, HEAT, COOL } = this.Characteristic.TargetHeaterCoolerState;
+        const validValues = [HEAT];
+        this.mainService().getCharacteristic(this.Characteristic.TargetHeaterCoolerState)
+            .onGet(() => {
+            // Since setting the mode to AUTO prevents temperature adjustments in the iPhone Home app, the default mode will be set to HEAT.
+            return HEAT;
+        })
+            .onSet(async (value) => {
+            // TODO
+            this.log.debug('configureTargetState set:' + value);
+        })
+            .setProps({ validValues });
+    }
+    configureHeatingThresholdTemp() {
+        const schema = this.getSchema(...SCHEMA_CODE.TARGET_TEMP);
+        if (!schema) {
+            return;
+        }
+        const property = schema.property;
+        const props = (0, util_1.toHapProperty)(property);
+        const multiple = Math.pow(10, property['scale'] || 0);
+        this.log.debug('Set props for HeatingThresholdTemperature:', props);
+        this.mainService().getCharacteristic(this.Characteristic.HeatingThresholdTemperature)
+            .onGet(() => {
+            const status = this.getStatus(schema.code);
+            const temp = status.value / multiple;
+            return (0, util_1.limit)(temp, props['minValue'], props['maxValue']);
+        })
+            .onSet(async (value) => {
+            await this.sendCommands([{ code: schema.code, value: value * multiple }]);
+        })
+            .setProps(props);
+    }
+}
+exports.default = HeaterAccessory;
+//# sourceMappingURL=HeaterAccessory.js.map

package/dist/shared/accessories/HeaterAccessory_old.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util/util");
+const BaseAccessory_1 = __importDefault(require("./BaseAccessory"));
+const Active_1 = require("./characteristic/Active");
+const CurrentTemperature_1 = require("./characteristic/CurrentTemperature");
+const LockPhysicalControls_1 = require("./characteristic/LockPhysicalControls");
+const SwingMode_1 = require("./characteristic/SwingMode");
+const TemperatureDisplayUnits_1 = require("./characteristic/TemperatureDisplayUnits");
+const SCHEMA_CODE = {
+    ACTIVE: ['switch'],
+    WORK_STATE: ['work_state'],
+    CURRENT_TEMP: ['temp_current'],
+    TARGET_TEMP: ['temp_set'],
+    LOCK: ['lock'],
+    SWING: ['shake'],
+    TEMP_UNIT_CONVERT: ['temp_unit_convert', 'c_f'],
+};
+class HeaterAccessory_old extends BaseAccessory_1.default {
+    requiredSchema() {
+        return [SCHEMA_CODE.ACTIVE];
+    }
+    configureServices() {
+        (0, Active_1.configureActive)(this, this.mainService(), this.getSchema(...SCHEMA_CODE.ACTIVE));
+        this.configureCurrentState();
+        this.configureTargetState();
+        (0, CurrentTemperature_1.configureCurrentTemperature)(this, this.mainService(), this.getSchema(...SCHEMA_CODE.CURRENT_TEMP));
+        (0, LockPhysicalControls_1.configureLockPhysicalControls)(this, this.mainService(), this.getSchema(...SCHEMA_CODE.LOCK));
+        (0, SwingMode_1.configureSwingMode)(this, this.mainService(), this.getSchema(...SCHEMA_CODE.SWING));
+        this.configureHeatingThreshouldTemp();
+        (0, TemperatureDisplayUnits_1.configureTempDisplayUnits)(this, this.mainService(), this.getSchema(...SCHEMA_CODE.TEMP_UNIT_CONVERT));
+    }
+    mainService() {
+        return this.accessory.getService(this.Service.HeaterCooler)
+            || this.accessory.addService(this.Service.HeaterCooler);
+    }
+    configureCurrentState() {
+        const schema = this.getSchema(...SCHEMA_CODE.WORK_STATE);
+        const { INACTIVE, IDLE, HEATING } = this.Characteristic.CurrentHeaterCoolerState;
+        this.mainService().getCharacteristic(this.Characteristic.CurrentHeaterCoolerState)
+            .onGet(() => {
+            if (!schema) {
+                return IDLE;
+            }
+            const status = this.getStatus(schema.code);
+            if (status.value === 'heating') {
+                return HEATING;
+            }
+            else if (status.value === 'warming') {
+                return IDLE;
+            }
+            return INACTIVE;
+        });
+    }
+    configureTargetState() {
+        const { AUTO, HEAT, COOL } = this.Characteristic.TargetHeaterCoolerState;
+        const validValues = [AUTO];
+        this.mainService().getCharacteristic(this.Characteristic.TargetHeaterCoolerState)
+            .onGet(() => {
+            return AUTO;
+        })
+            .onSet(async (value) => {
+            // TODO
+        })
+            .setProps({ validValues });
+    }
+    configureHeatingThreshouldTemp() {
+        const schema = this.getSchema(...SCHEMA_CODE.TARGET_TEMP);
+        if (!schema) {
+            return;
+        }
+        const property = schema.property;
+        const multiple = property ? Math.pow(10, property.scale) : 1;
+        const props = {
+            minValue: property.min / multiple,
+            maxValue: property.max / multiple,
+            minStep: Math.max(0.1, property.step / multiple),
+        };
+        this.log.debug('Set props for HeatingThresholdTemperature:', props);
+        this.mainService().getCharacteristic(this.Characteristic.HeatingThresholdTemperature)
+            .onGet(() => {
+            const status = this.getStatus(schema.code);
+            const temp = status.value / multiple;
+            return (0, util_1.limit)(temp, props.minValue, props.maxValue);
+        })
+            .onSet(async (value) => {
+            await this.sendCommands([{ code: schema.code, value: value * multiple }]);
+        })
+            .setProps(props);
+    }
+}
+exports.default = HeaterAccessory_old;
+//# sourceMappingURL=HeaterAccessory_old.js.map

package/dist/shared/accessories/HumanPresenceSensorAccessory.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const BaseAccessory_1 = __importDefault(require("./BaseAccessory"));
+const OccupancyDetected_1 = require("./characteristic/OccupancyDetected");
+const SCHEMA_CODE = {
+    PRESENCE: ['presence_state'],
+};
+class HumanPresenceSensorAccessory extends BaseAccessory_1.default {
+    requiredSchema() {
+        return [SCHEMA_CODE.PRESENCE];
+    }
+    configureServices() {
+        (0, OccupancyDetected_1.configureOccupancyDetected)(this, undefined, this.getSchema(...SCHEMA_CODE.PRESENCE));
+    }
+}
+exports.default = HumanPresenceSensorAccessory;
+//# sourceMappingURL=HumanPresenceSensorAccessory.js.map

package/dist/shared/accessories/HumidifierAccessory.js

@@ -0,0 +1,137 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const util_1 = require("../util/util");
+const BaseAccessory_1 = __importDefault(require("./BaseAccessory"));
+const Active_1 = require("./characteristic/Active");
+const CurrentTemperature_1 = require("./characteristic/CurrentTemperature");
+const CurrentRelativeHumidity_1 = require("./characteristic/CurrentRelativeHumidity");
+const Light_1 = require("./characteristic/Light");
+const SCHEMA_CODE = {
+    ACTIVE: ['switch'],
+    CURRENT_HUMIDITY: ['humidity_current'],
+    TARGET_HUMIDITY: ['humidity_set'],
+    CURRENT_TEMP: ['temp_current'],
+    LIGHT_ON: ['switch_led'],
+    LIGHT_MODE: ['work_mode'],
+    LIGHT_BRIGHT: ['bright_value', 'bright_value_v2'],
+    LIGHT_COLOR: ['colour_data', 'colour_data_hsv'],
+};
+class HumidifierAccessory extends BaseAccessory_1.default {
+    requiredSchema() {
+        return [SCHEMA_CODE.ACTIVE];
+    }
+    configureServices() {
+        // Required Characteristics
+        (0, Active_1.configureActive)(this, this.mainService(), this.getSchema(...SCHEMA_CODE.ACTIVE));
+        this.configureCurrentState();
+        this.configureTargetState();
+        (0, CurrentRelativeHumidity_1.configureCurrentRelativeHumidity)(this, this.mainService(), this.getSchema(...SCHEMA_CODE.CURRENT_HUMIDITY));
+        // Optional Characteristics
+        this.configureRelativeHumidityHumidifierThreshold();
+        this.configureRotationSpeed();
+        // Other
+        (0, CurrentTemperature_1.configureCurrentTemperature)(this, undefined, this.getSchema(...SCHEMA_CODE.CURRENT_TEMP));
+        (0, Light_1.configureLight)(this, undefined, this.getSchema(...SCHEMA_CODE.LIGHT_ON), this.getSchema(...SCHEMA_CODE.LIGHT_BRIGHT), undefined, this.getSchema(...SCHEMA_CODE.LIGHT_COLOR), this.getSchema(...SCHEMA_CODE.LIGHT_MODE));
+    }
+    mainService() {
+        return this.accessory.getService(this.Service.HumidifierDehumidifier)
+            || this.accessory.addService(this.Service.HumidifierDehumidifier);
+    }
+    configureTargetState() {
+        const { HUMIDIFIER } = this.Characteristic.TargetHumidifierDehumidifierState;
+        const validValues = [HUMIDIFIER];
+        this.mainService().getCharacteristic(this.Characteristic.TargetHumidifierDehumidifierState)
+            .onGet(() => {
+            return HUMIDIFIER;
+        }).setProps({ validValues });
+    }
+    configureCurrentState() {
+        const schema = this.getSchema(...SCHEMA_CODE.ACTIVE);
+        if (!schema) {
+            this.log.warn('CurrentHumidifierDehumidifierState not supported.');
+            return;
+        }
+        const { INACTIVE, HUMIDIFYING } = this.Characteristic.CurrentHumidifierDehumidifierState;
+        this.mainService().getCharacteristic(this.Characteristic.CurrentHumidifierDehumidifierState)
+            .onGet(() => {
+            const status = this.getStatus(schema.code);
+            return status?.value ? HUMIDIFYING : INACTIVE;
+        });
+    }
+    configureRelativeHumidityHumidifierThreshold() {
+        const schema = this.getSchema(...SCHEMA_CODE.TARGET_HUMIDITY);
+        if (!schema) {
+            this.log.warn('Humidity setting is not supported.');
+            return;
+        }
+        const property = schema.property;
+        const multiple = Math.pow(10, property ? property.scale : 0);
+        const props = {
+            minValue: 0,
+            maxValue: 100,
+            minStep: Math.max(1, property.step / multiple),
+        };
+        this.log.debug('Set props for RelativeHumidityHumidifierThreshold:', props);
+        this.mainService().getCharacteristic(this.Characteristic.RelativeHumidityHumidifierThreshold)
+            .onGet(() => {
+            const status = this.getStatus(schema.code);
+            return (0, util_1.limit)(status.value / multiple, 0, 100);
+        })
+            .onSet(async (value) => {
+            const humidity_set = (0, util_1.limit)(value * multiple, property.min, property.max);
+            await this.sendCommands([{ code: schema.code, value: humidity_set }]);
+            // also set spray mode to humidity
+            await this.setSprayModeToHumidity();
+        }).setProps(props);
+    }
+    configureRotationSpeed() {
+        const schema = this.getSchema('mode');
+        if (!schema) {
+            this.log.warn('Mode setting is not supported.');
+            return;
+        }
+        const unusedService = this.accessory.getService(this.Service.Fan);
+        if (unusedService) {
+            this.accessory.removeService(unusedService);
+        }
+        this.mainService().getCharacteristic(this.Characteristic.RotationSpeed)
+            .onGet(() => {
+            const status = this.getStatus(schema.code);
+            let v = 3;
+            switch (status.value) {
+                case 'small':
+                    v = 1;
+                    break;
+                case 'middle':
+                    v = 2;
+                    break;
+            }
+            return (0, util_1.remap)(v, 0, 3, 0, 100);
+        }).onSet(async (value) => {
+            value = Math.round((0, util_1.remap)(value, 0, 100, 0, 3));
+            let mode = 'small';
+            switch (value) {
+                case 2:
+                    mode = 'middle';
+                    break;
+                case 3:
+                    mode = 'large';
+                    break;
+            }
+            await this.sendCommands([{ code: schema.code, value: mode }]);
+        });
+    }
+    async setSprayModeToHumidity() {
+        const schema = this.getSchema('spray_mode');
+        if (!schema) {
+            this.log.debug('Spray mode not supported.');
+            return;
+        }
+        await this.sendCommands([{ code: schema.code, value: 'humidity' }]);
+    }
+}
+exports.default = HumidifierAccessory;
+//# sourceMappingURL=HumidifierAccessory.js.map