homebridge-tuya-without-developer-account 1.0.0

package/dist/shared/accessories/IRAirConditionerAccessory.js

@@ -0,0 +1,278 @@
+"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 POWER_OFF = 0;
+const POWER_ON = 1;
+const AC_MODE_COOL = 0;
+const AC_MODE_HEAT = 1;
+const AC_MODE_AUTO = 2;
+const AC_MODE_FAN = 3;
+const AC_MODE_DEHUMIDIFIER = 4;
+const FAN_SPEED_AUTO = 0;
+const FAN_SPEED_LOW = 1;
+// const FAN_SPEED_MEDIUM = 2;
+const FAN_SPEED_HIGH = 3;
+class IRAirConditionerAccessory extends BaseAccessory_1.default {
+    constructor() {
+        super(...arguments);
+        this.debounceSendACCommands = (0, util_1.debounce)(this.sendACCommands, 100);
+    }
+    configureServices() {
+        this.configureAirConditioner();
+        this.configureDehumidifier();
+        this.configureFan();
+    }
+    configureAirConditioner() {
+        const service = this.mainService();
+        const { INACTIVE, ACTIVE } = this.Characteristic.Active;
+        // Required Characteristics
+        service.getCharacteristic(this.Characteristic.Active)
+            .onGet(() => {
+            return ([AC_MODE_COOL, AC_MODE_HEAT, AC_MODE_AUTO].includes(this.getMode()) && this.getPower() === POWER_ON) ? ACTIVE : INACTIVE;
+        })
+            .onSet(async (value) => {
+            if (value === ACTIVE) {
+                // Turn off Dehumidifier & Fan
+                this.supportDehumidifier() && this.dehumidifierService().getCharacteristic(this.Characteristic.Active).updateValue(INACTIVE);
+                this.supportFan() && this.fanService().getCharacteristic(this.Characteristic.Active).updateValue(INACTIVE);
+                this.fanService().getCharacteristic(this.Characteristic.Active).value = INACTIVE;
+            }
+            if (value === ACTIVE && ![AC_MODE_COOL, AC_MODE_HEAT, AC_MODE_AUTO].includes(this.getMode())) {
+                this.setMode(AC_MODE_AUTO);
+            }
+            this.setPower((value === ACTIVE) ? POWER_ON : POWER_OFF);
+        });
+        const { IDLE } = this.Characteristic.CurrentHeaterCoolerState;
+        service.setCharacteristic(this.Characteristic.CurrentHeaterCoolerState, IDLE);
+        this.configureTargetState();
+        this.configureCurrentTemperature();
+        // Optional Characteristics
+        this.configureRotationSpeed(service);
+        const key_range = this.device.remote_keys?.key_range || [];
+        if (key_range.find(item => item.mode === AC_MODE_HEAT)) {
+            const [minValue, maxValue] = this.getTempRange(AC_MODE_HEAT);
+            service.getCharacteristic(this.Characteristic.HeatingThresholdTemperature)
+                .onGet(() => {
+                if (this.getMode() === AC_MODE_AUTO) {
+                    return minValue;
+                }
+                return this.getTemp();
+            })
+                .onSet(async (value) => {
+                if (this.getMode() === AC_MODE_AUTO) {
+                    return;
+                }
+                this.setTemp(value);
+            })
+                .setProps({ minValue, maxValue, minStep: 1 });
+        }
+        if (key_range.find(item => item.mode === AC_MODE_COOL)) {
+            const [minValue, maxValue] = this.getTempRange(AC_MODE_COOL);
+            service.getCharacteristic(this.Characteristic.CoolingThresholdTemperature)
+                .onGet(this.getTemp.bind(this))
+                .onSet(this.setTemp.bind(this))
+                .setProps({ minValue, maxValue, minStep: 1 });
+        }
+    }
+    configureDehumidifier() {
+        if (!this.supportDehumidifier()) {
+            return;
+        }
+        const service = this.dehumidifierService();
+        const { INACTIVE, ACTIVE } = this.Characteristic.Active;
+        // Required Characteristics
+        service.getCharacteristic(this.Characteristic.Active)
+            .onGet(() => {
+            return (this.getMode() === AC_MODE_DEHUMIDIFIER && this.getPower() === POWER_ON) ? ACTIVE : INACTIVE;
+        })
+            .onSet(async (value) => {
+            if (value === ACTIVE) {
+                // Turn off AC & Fan
+                this.mainService().getCharacteristic(this.Characteristic.Active).updateValue(INACTIVE);
+                this.supportFan() && this.fanService().getCharacteristic(this.Characteristic.Active).updateValue(INACTIVE);
+            }
+            this.setMode(AC_MODE_DEHUMIDIFIER);
+            this.setPower((value === ACTIVE) ? POWER_ON : POWER_OFF);
+        });
+        const { DEHUMIDIFYING } = this.Characteristic.CurrentHumidifierDehumidifierState;
+        service.setCharacteristic(this.Characteristic.CurrentHumidifierDehumidifierState, DEHUMIDIFYING);
+        const { DEHUMIDIFIER } = this.Characteristic.TargetHumidifierDehumidifierState;
+        service.getCharacteristic(this.Characteristic.TargetHumidifierDehumidifierState)
+            .updateValue(DEHUMIDIFIER)
+            .setProps({ validValues: [DEHUMIDIFIER] });
+        service.getCharacteristic(this.Characteristic.CurrentRelativeHumidity)
+            .onGet(() => {
+            const handler = this.getParentAccessory().accessory
+                .getService(this.Service.HumiditySensor)
+                ?.getCharacteristic(this.Characteristic.CurrentRelativeHumidity)['getHandler'];
+            const humidity = handler ? handler() : 0;
+            return humidity;
+        });
+        // Optional Characteristics
+        this.configureRotationSpeed(service);
+    }
+    configureFan() {
+        if (!this.supportFan()) {
+            return;
+        }
+        const service = this.fanService();
+        const { INACTIVE, ACTIVE } = this.Characteristic.Active;
+        // Required Characteristics
+        service.getCharacteristic(this.Characteristic.Active)
+            .onGet(() => {
+            return (this.getMode() === AC_MODE_FAN && this.getPower() === POWER_ON) ? ACTIVE : INACTIVE;
+        })
+            .onSet(async (value) => {
+            if (value === ACTIVE) {
+                // Turn off AC & Dehumidifier
+                this.mainService().getCharacteristic(this.Characteristic.Active).updateValue(INACTIVE);
+                this.supportDehumidifier() && this.dehumidifierService().getCharacteristic(this.Characteristic.Active).updateValue(INACTIVE);
+            }
+            this.setMode(AC_MODE_FAN);
+            this.setPower((value === ACTIVE) ? POWER_ON : POWER_OFF);
+        });
+        // Optional Characteristics
+        this.configureTargetFanState(service);
+        this.configureRotationSpeed(service);
+    }
+    mainService() {
+        return this.accessory.getService(this.Service.HeaterCooler)
+            || this.accessory.addService(this.Service.HeaterCooler);
+    }
+    dehumidifierService() {
+        return this.accessory.getService(this.Service.HumidifierDehumidifier)
+            || this.accessory.addService(this.Service.HumidifierDehumidifier, this.accessory.displayName + ' Dehumidifier');
+    }
+    fanService() {
+        return this.accessory.getService(this.Service.Fanv2)
+            || this.accessory.addService(this.Service.Fanv2, this.accessory.displayName + ' Fan');
+    }
+    getPower() {
+        const value = this.getStatus('power')?.value || '0';
+        return (value === true || parseInt(value.toString()) === 1) ? POWER_ON : POWER_OFF;
+    }
+    setPower(value) {
+        this.getStatus('power').value = value;
+        this.debounceSendACCommands();
+    }
+    getMode() {
+        const value = this.getStatus('mode')?.value || '0';
+        return parseInt(value.toString());
+    }
+    setMode(value) {
+        this.getStatus('mode').value = value;
+        this.debounceSendACCommands();
+    }
+    getWind() {
+        const value = this.getStatus('wind')?.value || '0';
+        return parseInt(value.toString());
+    }
+    setWind(value) {
+        this.getStatus('wind').value = value;
+        this.debounceSendACCommands();
+    }
+    getTemp() {
+        const value = this.getStatus('temp')?.value || '0';
+        return parseInt(value.toString());
+    }
+    setTemp(value) {
+        this.getStatus('temp').value = value;
+        this.debounceSendACCommands();
+    }
+    getKeyRangeItem(mode) {
+        const key_range = this.device.remote_keys?.key_range || [];
+        return key_range.find(item => item.mode === mode);
+    }
+    supportDehumidifier() {
+        return this.getKeyRangeItem(AC_MODE_DEHUMIDIFIER) !== undefined;
+    }
+    supportFan() {
+        return this.getKeyRangeItem(AC_MODE_FAN) !== undefined;
+    }
+    getTempRange(mode) {
+        const keyRangeItem = this.getKeyRangeItem(mode);
+        if (!keyRangeItem || !keyRangeItem.temp_list || keyRangeItem.temp_list.length === 0) {
+            return undefined;
+        }
+        const tempList = keyRangeItem.temp_list.map((temp) => temp.temp);
+        const min = Math.min(...tempList);
+        const max = Math.max(...tempList);
+        return [min, max];
+    }
+    getParentAccessory() {
+        return this.platform.accessoryHandlers.find(accessory => accessory.device.id === this.device.parent_id);
+    }
+    configureTargetState() {
+        const { AUTO, HEAT, COOL } = this.Characteristic.TargetHeaterCoolerState;
+        const validValues = [];
+        const key_range = this.device.remote_keys?.key_range || [];
+        if (key_range.find(item => item.mode === AC_MODE_AUTO)) {
+            validValues.push(AUTO);
+        }
+        if (key_range.find(item => item.mode === AC_MODE_HEAT)) {
+            validValues.push(HEAT);
+        }
+        if (key_range.find(item => item.mode === AC_MODE_COOL)) {
+            validValues.push(COOL);
+        }
+        if (validValues.length === 0) {
+            this.log.warn('Invalid mode range for TargetHeaterCoolerState:', key_range);
+            return;
+        }
+        this.mainService().getCharacteristic(this.Characteristic.TargetHeaterCoolerState)
+            .onGet(() => ({
+            [AC_MODE_COOL.toString()]: COOL,
+            [AC_MODE_HEAT.toString()]: HEAT,
+            [AC_MODE_AUTO.toString()]: AUTO,
+        }[this.getMode().toString()] || AUTO))
+            .onSet(async (value) => {
+            this.setMode({
+                [COOL.toString()]: AC_MODE_COOL,
+                [HEAT.toString()]: AC_MODE_HEAT,
+                [AUTO.toString()]: AC_MODE_AUTO,
+            }[value.toString()]);
+        })
+            .setProps({ validValues });
+    }
+    configureCurrentTemperature() {
+        this.mainService().getCharacteristic(this.Characteristic.CurrentTemperature)
+            .onGet(() => {
+            const handler = this.getParentAccessory().accessory
+                .getService(this.Service.TemperatureSensor)
+                ?.getCharacteristic(this.Characteristic.CurrentTemperature)['getHandler'];
+            const temp = handler ? handler() : this.getTemp();
+            return temp;
+        });
+    }
+    configureTargetFanState(service) {
+        const { MANUAL, AUTO } = this.Characteristic.TargetFanState;
+        service.getCharacteristic(this.Characteristic.TargetFanState)
+            .onGet(() => (this.getWind() === FAN_SPEED_AUTO) ? AUTO : MANUAL)
+            .onSet(async (value) => {
+            this.setWind((value === AUTO) ? FAN_SPEED_AUTO : FAN_SPEED_LOW);
+        });
+    }
+    configureRotationSpeed(service) {
+        service.getCharacteristic(this.Characteristic.RotationSpeed)
+            .onGet(() => (this.getWind() === FAN_SPEED_AUTO) ? FAN_SPEED_HIGH : this.getWind())
+            .onSet(async (value) => {
+            // if (this.getWind() === FAN_SPEED_AUTO) {
+            //   return;
+            // }
+            if (value !== 0) {
+                this.setWind(value);
+            }
+        })
+            .setProps({ minValue: 0, maxValue: 3, minStep: 1, unit: 'speed' });
+    }
+    async sendACCommands() {
+        const { parent_id, id } = this.device;
+        await this.deviceManager.sendInfraredACCommands(parent_id, id, this.getPower(), this.getMode(), this.getTemp(), this.getWind());
+    }
+}
+exports.default = IRAirConditionerAccessory;
+//# sourceMappingURL=IRAirConditionerAccessory.js.map

package/dist/shared/accessories/IRControlHubAccessory.js

@@ -0,0 +1,49 @@
+"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"));
+// import { configureCurrentAbsoluteHumidity } from './characteristic/CurrentAbsoluteHumidity';
+const CurrentRelativeHumidity_1 = require("./characteristic/CurrentRelativeHumidity");
+const CurrentTemperature_1 = require("./characteristic/CurrentTemperature");
+const LightSensor_1 = require("./characteristic/LightSensor");
+const SCHEMA_CODE = {
+    CURRENT_TEMP: ['va_temperature', 'temp_value'],
+    CURRENT_HUMIDITY: ['va_humidity', 'humidity_value'],
+    LIGHT_SENSOR: ['bright_value'],
+};
+class IRControlHubAccessory extends BaseAccessory_1.default {
+    requiredSchema() {
+        return [];
+    }
+    configureServices() {
+        (0, CurrentTemperature_1.configureCurrentTemperature)(this, undefined, this.getSchema(...SCHEMA_CODE.CURRENT_TEMP));
+        (0, CurrentRelativeHumidity_1.configureCurrentRelativeHumidity)(this, undefined, this.getSchema(...SCHEMA_CODE.CURRENT_HUMIDITY));
+        (0, LightSensor_1.configureLightSensor)(this, undefined, this.getSchema(...SCHEMA_CODE.LIGHT_SENSOR));
+        // eslint-disable-next-line max-len
+        //    configureCurrentAbsoluteHumidity(this.platform.api, this, undefined, this.getSchema(...SCHEMA_CODE.CURRENT_HUMIDITY), this.getSchema(...SCHEMA_CODE.CURRENT_TEMP));
+        const key = `wbgt-${this.device.id}`;
+        const uuid = this.platform.api.hap.uuid.generate(key);
+        if (!this.deviceManager.devices.some(device => device.uuid === uuid)) {
+            this.log.info(`add wbgt device:${key}`);
+            const virtualDevice = this.deviceManager.createVirtualDevice(this.device, uuid);
+            virtualDevice.product_id = 'virtual-product-id-wbgt';
+            virtualDevice.category = 'wsdcg';
+            virtualDevice.name = 'WBGT';
+            this.deviceManager.devices.push(virtualDevice);
+        }
+    }
+    getSubAccessories() {
+        return this.platform.accessoryHandlers.filter(accessory => accessory.device.parent_id === this.device.id);
+    }
+    async onDeviceStatusUpdate(status) {
+        super.onDeviceStatusUpdate(status);
+        // Trigger sub device update temperature & humidity from parent device.
+        for (const subAccessory of this.getSubAccessories()) {
+            await subAccessory.updateAllValues();
+        }
+    }
+}
+exports.default = IRControlHubAccessory;
+//# sourceMappingURL=IRControlHubAccessory.js.map

package/dist/shared/accessories/IRControlHubSubAccessory.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const InfraredTool_1 = require("../util/InfraredTool");
+const BaseAccessory_1 = __importDefault(require("./BaseAccessory"));
+const Name_1 = require("./characteristic/Name");
+class IRControlHubSubAccessory extends BaseAccessory_1.default {
+    configureServices() {
+        let key_list = this.device.remote_keys?.key_list || [];
+        // Max 99 services allowed (one for AccessoryInformation)
+        if (key_list.length > 99) {
+            this.log.warn(`Skipping ${key_list.length - 99} keys for ${this.device.name}, ` +
+                'as we reached the limit of HomeKit (100 services per accessory)');
+        }
+        key_list = key_list.slice(0, 99);
+        for (const key of key_list) {
+            this.configureSwitch(key);
+        }
+    }
+    configureSwitch(key) {
+        const service = this.accessory.getService(key.key)
+            || this.accessory.addService(this.Service.Switch, key.key, key.key);
+        (0, Name_1.configureName)(this, service, key.key_name);
+        service.getCharacteristic(this.Characteristic.On)
+            .onGet(() => false)
+            .onSet(async (value) => {
+            if (value === false) {
+                return;
+            }
+            this.sendInfraredCommands(key);
+            setTimeout(() => {
+                service.getCharacteristic(this.Characteristic.On).updateValue(false);
+            }, 150);
+        });
+    }
+    async sendInfraredCommands(key) {
+        const { parent_id, id } = this.device;
+        const { category_id, remote_index } = this.device.remote_keys;
+        if (key.learning_code) {
+            const buffer = (0, InfraredTool_1.internalCodeToBase64)(key.learning_code, { trimPadding: true, endian: 'LE' });
+            const commands = [{ 'code': 'key_data', 'value': buffer }];
+            await this.deviceManager.sendCommands(parent_id || id, commands);
+        }
+        else {
+            await this.deviceManager.sendInfraredCommands(parent_id, id, category_id, remote_index, key.key, key.key_id);
+        }
+    }
+}
+exports.default = IRControlHubSubAccessory;
+//# sourceMappingURL=IRControlHubSubAccessory.js.map

package/dist/shared/accessories/IRGenericAccessory.js

@@ -0,0 +1,49 @@
+"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 Name_1 = require("./characteristic/Name");
+class IRGenericAccessory extends BaseAccessory_1.default {
+    configureServices() {
+        let key_list = this.device.remote_keys?.key_list || [];
+        // Max 99 services allowed (one for AccessoryInformation)
+        if (key_list.length > 99) {
+            this.log.warn(`Skipping ${key_list.length - 99} keys for ${this.device.name}, ` +
+                'as we reached the limit of HomeKit (100 services per accessory)');
+        }
+        key_list = key_list.slice(0, 99);
+        for (const key of key_list) {
+            this.configureSwitch(key);
+        }
+    }
+    configureSwitch(key) {
+        const service = this.accessory.getService(key.key)
+            || this.accessory.addService(this.Service.Switch, key.key, key.key);
+        (0, Name_1.configureName)(this, service, key.key_name);
+        service.getCharacteristic(this.Characteristic.On)
+            .onGet(() => false)
+            .onSet(async (value) => {
+            if (value === false) {
+                return;
+            }
+            this.sendInfraredCommands(key);
+            setTimeout(() => {
+                service.getCharacteristic(this.Characteristic.On).updateValue(false);
+            }, 150);
+        });
+    }
+    async sendInfraredCommands(key) {
+        const { parent_id, id } = this.device;
+        const { category_id, remote_index } = this.device.remote_keys;
+        if (key.learning_code) {
+            await this.deviceManager.sendInfraredDIYCommands(parent_id, id, key.learning_code);
+        }
+        else {
+            await this.deviceManager.sendInfraredCommands(parent_id, id, category_id, remote_index, key.key, key.key_id);
+        }
+    }
+}
+exports.default = IRGenericAccessory;
+//# sourceMappingURL=IRGenericAccessory.js.map

package/dist/shared/accessories/LeakSensorAccessory.js

@@ -0,0 +1,36 @@
+"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 = {
+    LEAK: ['gas_sensor_status', 'gas_sensor_state', 'ch4_sensor_state', 'watersensor_state'],
+};
+class LeakSensor extends BaseAccessory_1.default {
+    requiredSchema() {
+        return [SCHEMA_CODE.LEAK];
+    }
+    configureServices() {
+        const { LEAK_NOT_DETECTED, LEAK_DETECTED } = this.Characteristic.LeakDetected;
+        const service = this.accessory.getService(this.Service.LeakSensor)
+            || this.accessory.addService(this.Service.LeakSensor);
+        service.getCharacteristic(this.Characteristic.LeakDetected)
+            .onGet(() => {
+            const gas = this.getStatus('gas_sensor_status')
+                || this.getStatus('gas_sensor_state');
+            const ch4 = this.getStatus('ch4_sensor_state');
+            const water = this.getStatus('watersensor_state');
+            if ((gas && (gas.value === 'alarm' || gas.value === '1'))
+                || (ch4 && ch4.value === 'alarm')
+                || (water && water.value === 'alarm')) {
+                return LEAK_DETECTED;
+            }
+            else {
+                return LEAK_NOT_DETECTED;
+            }
+        });
+    }
+}
+exports.default = LeakSensor;
+//# sourceMappingURL=LeakSensorAccessory.js.map

package/dist/shared/accessories/LightAccessory.js

@@ -0,0 +1,36 @@
+"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 On_1 = require("./characteristic/On");
+const MotionDetected_1 = require("./characteristic/MotionDetected");
+const Light_1 = require("./characteristic/Light");
+const SCHEMA_CODE = {
+    ON: ['switch_led'],
+    BRIGHTNESS: ['bright_value', 'bright_value_v2'],
+    COLOR_TEMP: ['temp_value', 'temp_value_v2'],
+    COLOR: ['colour_data', 'colour_data_v2'],
+    WORK_MODE: ['work_mode'],
+    PIR: ['pir_state'],
+    PIR_ON: ['switch_pir'],
+    POWER_SWITCH: ['switch'],
+};
+class LightAccessory extends BaseAccessory_1.default {
+    requiredSchema() {
+        return [SCHEMA_CODE.ON];
+    }
+    configureServices() {
+        const service = this.accessory.getService(this.Service.Lightbulb)
+            || this.accessory.addService(this.Service.Lightbulb);
+        (0, Light_1.configureLight)(this, service, this.getSchema(...SCHEMA_CODE.ON), this.getSchema(...SCHEMA_CODE.BRIGHTNESS), this.getSchema(...SCHEMA_CODE.COLOR_TEMP), this.getSchema(...SCHEMA_CODE.COLOR), this.getSchema(...SCHEMA_CODE.WORK_MODE));
+        // PIR
+        (0, On_1.configureOn)(this, undefined, this.getSchema(...SCHEMA_CODE.PIR_ON));
+        (0, MotionDetected_1.configureMotionDetected)(this, undefined, this.getSchema(...SCHEMA_CODE.PIR));
+        // RGB Power Switch
+        (0, On_1.configureOn)(this, undefined, this.getSchema(...SCHEMA_CODE.POWER_SWITCH));
+    }
+}
+exports.default = LightAccessory;
+//# sourceMappingURL=LightAccessory.js.map

package/dist/shared/accessories/LightSensorAccessory.js

@@ -0,0 +1,32 @@
+"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 SCHEMA_CODE = {
+    BRIGHT_LEVEL: ['bright_value'],
+};
+class LightSensorAccessory extends BaseAccessory_1.default {
+    requiredSchema() {
+        return [SCHEMA_CODE.BRIGHT_LEVEL];
+    }
+    configureServices() {
+        const schema = this.getSchema(...SCHEMA_CODE.BRIGHT_LEVEL);
+        if (!schema) {
+            return;
+        }
+        const service = this.accessory.getService(this.Service.LightSensor)
+            || this.accessory.addService(this.Service.LightSensor);
+        const property = schema.property;
+        const multiple = Math.pow(10, property ? property.scale : 0);
+        service.getCharacteristic(this.Characteristic.CurrentAmbientLightLevel)
+            .onGet(() => {
+            const status = this.getStatus(schema.code);
+            return (0, util_1.limit)(status.value / multiple, 0.0001, 100000);
+        });
+    }
+}
+exports.default = LightSensorAccessory;
+//# sourceMappingURL=LightSensorAccessory.js.map

package/dist/shared/accessories/LocationWeatherAccessory.js

@@ -0,0 +1,72 @@
+"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 CurrentWeather_1 = require("./characteristic/CurrentWeather");
+const CurrentWeatherByOpenMeteo_1 = require("./characteristic/CurrentWeatherByOpenMeteo");
+class LocationWeatherAccessory extends BaseAccessory_1.default {
+    constructor() {
+        super(...arguments);
+        this.weatherConditionTuya = {
+            coordinate: {
+                lon: '0',
+                lat: '0',
+            },
+            air_quality: {
+                o3: '0',
+                pm10: '0',
+                co: '0',
+                no2: '0',
+                pm25: '0',
+                so2: '0',
+                aqi: '0',
+            },
+            current_weather: {
+                temp: '0',
+                real_feel: '0',
+                uvi: '0',
+                pressure: '0',
+                condition: '0',
+                condition_num: '0',
+                humidity: '0',
+                wind_speed: '0',
+            },
+        };
+        this.weatherConditionOpenMeteo = {
+            latitude: 0,
+            longitude: 0,
+            generationtime_ms: 0,
+            utc_offset_seconds: 0,
+            timezone: '',
+            timezone_abbreviation: '',
+            elevation: 0,
+            current_units: {
+                time: '',
+                interval: '',
+                temperature_2m: '',
+                relative_humidity_2m: '',
+            },
+            current: {
+                time: '',
+                interval: 0,
+                temperature_2m: 0,
+                relative_humidity_2m: 0,
+            },
+        };
+    }
+    requiredSchema() {
+        return [];
+    }
+    configureServices() {
+        if (this.platform.options.weatherAPI === 'Tuya') {
+            (0, CurrentWeather_1.configureCurrentWeather)(this, this.weatherConditionTuya);
+        }
+        else {
+            (0, CurrentWeatherByOpenMeteo_1.configureCurrentWeatherByOpenMeteo)(this, this.weatherConditionOpenMeteo);
+        }
+    }
+}
+exports.default = LocationWeatherAccessory;
+//# sourceMappingURL=LocationWeatherAccessory.js.map

package/dist/shared/accessories/LockAccessory.js

@@ -0,0 +1,56 @@
+"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 = {
+    LOCK_CURRENT_STATE: ['open_close', 'closed_opened', 'lock_motor_state'],
+    LOCK_TARGET_STATE: ['lock_motor_state'],
+};
+class LockAccessory extends BaseAccessory_1.default {
+    requiredSchema() {
+        return [SCHEMA_CODE.LOCK_CURRENT_STATE];
+    }
+    configureServices() {
+        this.configureLockCurrentState();
+        this.configureLockTargetState();
+    }
+    mainService() {
+        return this.accessory.getService(this.Service.LockMechanism)
+            || this.accessory.addService(this.Service.LockMechanism);
+    }
+    configureLockCurrentState() {
+        const schema = this.getSchema(...SCHEMA_CODE.LOCK_CURRENT_STATE);
+        if (!schema) {
+            return;
+        }
+        const { UNSECURED, SECURED } = this.Characteristic.LockCurrentState;
+        this.mainService().getCharacteristic(this.Characteristic.LockCurrentState)
+            .onGet(() => {
+            const status = this.getStatus(schema.code);
+            return status.value ? UNSECURED : SECURED;
+        });
+    }
+    configureLockTargetState() {
+        const schema = this.getSchema(...SCHEMA_CODE.LOCK_TARGET_STATE);
+        if (!schema) {
+            return;
+        }
+        const { UNSECURED, SECURED } = this.Characteristic.LockTargetState;
+        this.mainService().getCharacteristic(this.Characteristic.LockTargetState)
+            .onGet(() => {
+            const status = this.getStatus(schema.code);
+            return status.value ? UNSECURED : SECURED;
+        })
+            .onSet(async (value) => {
+            const res = await this.deviceManager.getLockTemporaryKey(this.device.id);
+            if (!res.success) {
+                return;
+            }
+            await this.deviceManager.sendLockCommands(this.device.id, res.result.ticket_id, (value === UNSECURED));
+        });
+    }
+}
+exports.default = LockAccessory;
+//# sourceMappingURL=LockAccessory.js.map