homebridge-bond 3.2.9

package/dist/accessories/LightAccessory.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LightAccessory = void 0;
+const Device_1 = require("../interface/Device");
+const Observer_1 = require("../Observer");
+const Services_1 = require("../Services");
+class LightAccessory {
+    constructor(platform, accessory, bond) {
+        this.platform = platform;
+        this.accessory = accessory;
+        this.lightService = new Services_1.LightbulbService(platform, accessory, `${accessory.displayName} Light`);
+        if (platform.config.include_toggle_state) {
+            this.toggleLightService = new Services_1.ButtonService(platform, accessory, 'Toggle Light State', 'ToggleState');
+        }
+        else {
+            this.removeService('Toggle Light State');
+        }
+        this.observe(bond);
+    }
+    updateState(state) {
+        this.lightService.updateState(state);
+    }
+    observe(bond) {
+        const device = this.accessory.context.device;
+        if (Device_1.Device.LThasLightbulb(device)) {
+            this.lightService.observe(this.platform, bond, this.accessory);
+        }
+        else {
+            this.platform.error(this.accessory, 'LightAccessory does not have required ToggleLight action.');
+        }
+        this.observeLightToggle(bond, device);
+    }
+    observeLightToggle(bond, device) {
+        if (!this.toggleLightService) {
+            return;
+        }
+        Observer_1.Observer.set(this.toggleLightService.on, (_, callback) => {
+            bond.api.toggleState(device, 'light', callback)
+                .then(() => {
+                this.platform.debug(this.accessory, `${device.name} light state toggled`);
+            })
+                .catch((error) => {
+                this.platform.error(this.accessory, `Error toggling light state: ${error}`);
+            });
+        });
+    }
+    removeService(serviceName) {
+        const service = this.accessory.getService(serviceName);
+        if (service) {
+            this.accessory.removeService(service);
+        }
+    }
+}
+exports.LightAccessory = LightAccessory;

package/dist/accessories/ShadesAccessory.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShadesAccessory = void 0;
+const Device_1 = require("../interface/Device");
+const Observer_1 = require("../Observer");
+const Services_1 = require("../Services");
+class ShadesAccessory {
+    constructor(platform, accessory, bond) {
+        this.platform = platform;
+        this.accessory = accessory;
+        const device = accessory.context.device;
+        this.windowCoveringService = new Services_1.WindowCoveringService(platform, accessory);
+        if (platform.config.include_toggle_state) {
+            this.toggleStateService = new Services_1.ButtonService(platform, accessory, 'Toggle State', 'ToggleState');
+        }
+        else {
+            this.removeService('Toggle State');
+        }
+        if (Device_1.Device.MShasPreset(device)) {
+            this.presetService = new Services_1.ButtonService(platform, accessory, 'Preset', 'Preset');
+        }
+        this.observe(bond);
+    }
+    updateState(state) {
+        if (this.windowCoveringService) {
+            // Always return either 0 or 100
+            this.windowCoveringService.currentPosition.updateValue(state.open === 1 ? 100 : 0);
+            this.windowCoveringService.targetPosition.updateValue(state.open === 1 ? 100 : 0);
+        }
+    }
+    observe(bond) {
+        const device = this.accessory.context.device;
+        this.observeWindowCovering(bond, device);
+        this.observePreset(bond, device);
+        this.observeToggleState(bond, device);
+    }
+    observeWindowCovering(bond, device) {
+        if (!Device_1.Device.MShasToggle(device)) {
+            this.platform.error(this.accessory, 'ShadesAccessory does not have required ToggleOpen action.');
+            return;
+        }
+        // Set initial state
+        bond.api.getState(device.id).then(state => {
+            this.updateState(state);
+        });
+        const props = {
+            minValue: 0,
+            maxValue: 100,
+            minStep: 100,
+        };
+        this.windowCoveringService.targetPosition.setProps(props);
+        Observer_1.Observer.set(this.windowCoveringService.targetPosition, (value, callback) => {
+            // Since we can't really track state, just toggle open / closed
+            bond.api.toggleOpen(device, callback)
+                .then(() => {
+                this.platform.debug(this.accessory, `Toggled open: ${value}`);
+            })
+                .catch((error) => {
+                this.platform.error(this.accessory, `Error toggling open: ${error}`);
+            });
+        });
+    }
+    observePreset(bond, device) {
+        if (!this.presetService) {
+            return;
+        }
+        Observer_1.Observer.set(this.presetService.on, (_, callback) => {
+            bond.api.preset(device, callback)
+                .then(() => {
+                this.platform.debug(this.accessory, 'Executed shade preset');
+            })
+                .catch((error) => {
+                this.platform.error(this.accessory, `Error executing preset: ${error}`);
+            });
+        });
+    }
+    observeToggleState(bond, device) {
+        if (!this.toggleStateService) {
+            return;
+        }
+        Observer_1.Observer.set(this.toggleStateService.on, (_, callback) => {
+            bond.api.toggleState(device, 'open', callback)
+                .then(() => {
+                this.platform.debug(this.accessory, `${device.name} open state toggled`);
+            })
+                .catch((error) => {
+                this.platform.error(this.accessory, `Error toggling open state: ${error}`);
+            });
+        });
+    }
+    removeService(serviceName) {
+        const service = this.accessory.getService(serviceName);
+        if (service) {
+            this.accessory.removeService(service);
+        }
+    }
+}
+exports.ShadesAccessory = ShadesAccessory;

package/dist/enum/Action.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Action = void 0;
+var Action;
+(function (Action) {
+    Action["ToggleLight"] = "ToggleLight";
+    Action["ToggleUpLight"] = "ToggleUpLight";
+    Action["ToggleDownLight"] = "ToggleDownLight";
+    Action["TurnOff"] = "TurnOff";
+    Action["TurnOn"] = "TurnOn";
+    Action["StartDimmer"] = "StartDimmer";
+    Action["StartUpLightDimmer"] = "StartUpLightDimmer";
+    Action["StartDownLightDimmer"] = "StartDownLightDimmer";
+    Action["StartIncreasingBrightness"] = "StartIncreasingBrightness";
+    Action["StartDecreasingBrightness"] = "StartDecreasingBrightness";
+    Action["Stop"] = "Stop";
+    Action["SetBrightness"] = "SetBrightness";
+    Action["SetSpeed"] = "SetSpeed";
+    Action["IncreaseSpeed"] = "IncreaseSpeed";
+    Action["DecreaseSpeed"] = "DecreaseSpeed";
+    Action["ToggleDirection"] = "ToggleDirection";
+    Action["TogglePower"] = "TogglePower";
+    Action["ToggleOpen"] = "ToggleOpen";
+    Action["TurnLightOff"] = "TurnLightOff";
+    Action["Open"] = "Open";
+    Action["Close"] = "Close";
+    Action["Preset"] = "Preset";
+    Action["SetFlame"] = "SetFlame";
+})(Action = exports.Action || (exports.Action = {}));

package/dist/enum/DeviceType.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeviceType = void 0;
+var DeviceType;
+(function (DeviceType) {
+    DeviceType["CeilingFan"] = "CF";
+    DeviceType["Shades"] = "MS";
+    DeviceType["Generic"] = "GX";
+    DeviceType["Fireplace"] = "FP";
+    DeviceType["Light"] = "LT";
+})(DeviceType = exports.DeviceType || (exports.DeviceType = {}));

package/dist/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const settings_1 = require("./settings");
+const platform_1 = require("./platform");
+/**
+ * This method registers the platform with Homebridge
+ */
+exports.default = (api) => {
+    api.registerPlatform(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, platform_1.BondPlatform);
+};

package/dist/interface/Bond.js

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BPUPMethod = exports.Bond = void 0;
+const BondApi_1 = require("../BondApi");
+const axios_1 = __importDefault(require("axios"));
+class Bond {
+    constructor(platform, config) {
+        this.platform = platform;
+        this.deviceIds = [];
+        this.accessories = [];
+        this.config = config;
+        this.api = new BondApi_1.BondApi(platform, config.token, config.ip_address);
+    }
+    // Helper to sanitze the config object into bond objects
+    static objects(platform) {
+        const config = platform.config;
+        const bondData = config.bonds;
+        const bondObjs = bondData.map(config => {
+            return new Bond(platform, config);
+        });
+        return bondObjs;
+    }
+    // Helper to update the device ids of a group of bonds
+    static validate(bonds) {
+        const ps = [];
+        bonds.forEach(bond => {
+            ps.push(bond.validate());
+        });
+        return Promise.all(ps);
+    }
+    validate() {
+        const bond = this;
+        return this.api
+            .ping()
+            .then(() => {
+            return bond;
+        })
+            .catch((error) => {
+            var _a;
+            if (axios_1.default.isAxiosError(error) && error.response) {
+                const response = error.response;
+                switch (response.status) {
+                    case 401:
+                        this.platform.log.error('Unauthorized. Please check the `token` in your config to see if it is correct.');
+                        return;
+                    default:
+                        this.platform.log.error(`A request error occurred: [status] ${response.status} [statusText] ${response.statusText}`);
+                }
+            }
+            else if (error.code === 'ECONNABORTED') {
+                this.platform.log.error(`Unable to find Bond for IP Address: ${bond.config.ip_address}. Skipping this Bond.`);
+            }
+            else {
+                this.platform.log.error(`A request error occurred: ${JSON.stringify(error)} [code] ${(_a = error.code) !== null && _a !== void 0 ? _a : ''}`);
+            }
+        });
+    }
+    // Helper to update the device ids of a group of bonds
+    static updateDeviceIds(bonds) {
+        const ps = [];
+        bonds.forEach(bond => {
+            ps.push(bond.updateDeviceIds());
+            ps.push(bond.updateBondId());
+        });
+        return Promise.all(ps);
+    }
+    updateDeviceIds() {
+        return this.api
+            .getDeviceIds()
+            .then(ids => {
+            this.deviceIds = ids;
+        })
+            .catch(error => {
+            this.platform.log.error(`Error getting device ids: ${error}`);
+        });
+    }
+    updateBondId() {
+        return this.api.getVersion()
+            .then(version => {
+            var _a, _b;
+            this.version = version;
+            this.platform.log.debug(`
+****** Bond Info *******
+ bondId: ${version.bondid}
+ FW: ${version.fw_ver}
+ API: v${version.api}
+ Make: ${(_a = version.make) !== null && _a !== void 0 ? _a : 'N/A'}
+ Model: ${(_b = version.model) !== null && _b !== void 0 ? _b : 'N/A'}\n************************`);
+        })
+            .catch(error => {
+            this.platform.log.error(`Error getting version: ${error}`);
+        });
+    }
+    // ID should be unique across multiple bonds in case device's have the same id across bonds.
+    uniqueDeviceId(deviceId) {
+        return `${this.version.bondid}${deviceId}`;
+    }
+    receivedBPUPPacket(packet) {
+        this.accessories.forEach(accessory => {
+            const device = accessory.accessory.context.device;
+            // Topic structure is 'devices/[device_id]/state'
+            if (packet.t
+                && packet.t.includes(device.id)
+                && packet.t.includes('state')
+                && packet.b) {
+                const state = packet.b;
+                this.platform.debug(accessory.accessory, 'Received new state: ' + JSON.stringify(state));
+                accessory.updateState(state);
+            }
+        });
+    }
+}
+exports.Bond = Bond;
+var BPUPMethod;
+(function (BPUPMethod) {
+    BPUPMethod[BPUPMethod["GET"] = 0] = "GET";
+    BPUPMethod[BPUPMethod["POST"] = 1] = "POST";
+    BPUPMethod[BPUPMethod["PUT"] = 2] = "PUT";
+    BPUPMethod[BPUPMethod["DELETE"] = 3] = "DELETE";
+    BPUPMethod[BPUPMethod["PATCH"] = 4] = "PATCH";
+})(BPUPMethod = exports.BPUPMethod || (exports.BPUPMethod = {}));

package/dist/interface/Device.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Device = void 0;
+const Action_1 = require("../enum/Action");
+const DeviceType_1 = require("../enum/DeviceType");
+// eslint-disable-next-line @typescript-eslint/no-namespace
+var Device;
+(function (Device) {
+    function displayName(device) {
+        return `${device.location} ${device.name}`;
+    }
+    Device.displayName = displayName;
+    function isSupported(device) {
+        const supported = [DeviceType_1.DeviceType.CeilingFan, DeviceType_1.DeviceType.Generic, DeviceType_1.DeviceType.Fireplace, DeviceType_1.DeviceType.Shades, DeviceType_1.DeviceType.Light];
+        return supported.includes(device.type);
+    }
+    Device.isSupported = isSupported;
+    function HasDimmer(device) {
+        const dimmer = [Action_1.Action.StartDimmer];
+        return device.actions.some(r => dimmer.includes(r));
+    }
+    Device.HasDimmer = HasDimmer;
+    function HasSeparateDimmers(device) {
+        const required = [Action_1.Action.StartIncreasingBrightness, Action_1.Action.StartDecreasingBrightness];
+        return required.every(r => device.actions.includes(r));
+    }
+    Device.HasSeparateDimmers = HasSeparateDimmers;
+    function CFhasLightbulb(device) {
+        const lightbulb = [Action_1.Action.ToggleLight];
+        return device.actions.some(r => lightbulb.includes(r));
+    }
+    Device.CFhasLightbulb = CFhasLightbulb;
+    function CFhasUpDownLight(device) {
+        const required = [Action_1.Action.ToggleUpLight, Action_1.Action.ToggleDownLight];
+        return required.every(r => device.actions.includes(r));
+    }
+    Device.CFhasUpDownLight = CFhasUpDownLight;
+    function canSetSpeed(device) {
+        const required = [Action_1.Action.SetSpeed];
+        const hasSetSpeed = required.every(r => device.actions.includes(r));
+        const hasMaxSpeed = device.properties.max_speed !== undefined;
+        return hasSetSpeed && hasMaxSpeed;
+    }
+    Device.canSetSpeed = canSetSpeed;
+    function canIncreaseDecreaseSpeed(device) {
+        const required = [Action_1.Action.IncreaseSpeed, Action_1.Action.DecreaseSpeed];
+        return required.every(r => device.actions.includes(r));
+    }
+    Device.canIncreaseDecreaseSpeed = canIncreaseDecreaseSpeed;
+    function hasOffOn(device) {
+        const required = [Action_1.Action.TurnOff, Action_1.Action.TurnOn];
+        return required.every(r => device.actions.includes(r));
+    }
+    Device.hasOffOn = hasOffOn;
+    function hasReverseSwitch(device) {
+        const required = [Action_1.Action.ToggleDirection];
+        return required.every(r => device.actions.includes(r));
+    }
+    Device.hasReverseSwitch = hasReverseSwitch;
+    function GXhasToggle(device) {
+        const fan = [Action_1.Action.TogglePower];
+        return device.actions.some(r => fan.includes(r));
+    }
+    Device.GXhasToggle = GXhasToggle;
+    function FPhasToggle(device) {
+        const fan = [Action_1.Action.TogglePower];
+        return device.actions.some(r => fan.includes(r));
+    }
+    Device.FPhasToggle = FPhasToggle;
+    function FPhasFlame(device) {
+        const required = [Action_1.Action.SetFlame, Action_1.Action.TogglePower];
+        return required.every(r => device.actions.includes(r));
+    }
+    Device.FPhasFlame = FPhasFlame;
+    function MShasToggle(device) {
+        const fan = [Action_1.Action.ToggleOpen];
+        return device.actions.some(r => fan.includes(r));
+    }
+    Device.MShasToggle = MShasToggle;
+    function MShasPreset(device) {
+        const required = [Action_1.Action.Preset];
+        return required.every(r => device.actions.includes(r));
+    }
+    Device.MShasPreset = MShasPreset;
+    function LThasLightbulb(device) {
+        const lightbulb = [Action_1.Action.ToggleLight];
+        return device.actions.some(r => lightbulb.includes(r));
+    }
+    Device.LThasLightbulb = LThasLightbulb;
+    function LThasBrightness(device) {
+        const required = [Action_1.Action.SetBrightness, Action_1.Action.TurnLightOff];
+        return required.every(r => device.actions.includes(r));
+    }
+    Device.LThasBrightness = LThasBrightness;
+    function fanSpeeds(device) {
+        if (device.commands) {
+            const values = device.commands
+                .filter(cmd => {
+                // Find all of the commands associated with speed
+                return cmd.action === Action_1.Action.SetSpeed;
+            })
+                .sort((a, b) => {
+                // sort them
+                return a.argument < b.argument ? 0 : 1;
+            })
+                .map(cmd => {
+                // map down to the raw argument values from that command
+                return cmd.argument || 0;
+            });
+            return values.sort();
+        }
+        else if (device.properties.max_speed === undefined || device.properties.max_speed === null) {
+            return [];
+        }
+        else {
+            // Assume speeds 1 - max_speed
+            const max_speed = device.properties.max_speed;
+            const vals = Array(max_speed)
+                .fill(1)
+                .map((x, y) => x + y);
+            return vals.sort();
+        }
+    }
+    Device.fanSpeeds = fanSpeeds;
+})(Device = exports.Device || (exports.Device = {}));

package/dist/interface/Properties.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interface/Version.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/interface/config.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BondConfig = exports.BondPlatformConfig = void 0;
+// eslint-disable-next-line @typescript-eslint/no-namespace
+var BondPlatformConfig;
+(function (BondPlatformConfig) {
+    function isValid(platform) {
+        const cast = platform.config;
+        function evaluate(type, key) {
+            const value = cast[key];
+            if (value !== undefined && typeof (value) !== type) {
+                platform.log.error(`${key} has invalid value: ${value}. Expected ${type}, got ${typeof (value)}.`);
+                return false;
+            }
+            return true;
+        }
+        const validDimmer = evaluate('boolean', 'include_dimmer');
+        const validFanSpeed = evaluate('boolean', 'fan_speed_values');
+        const validToggleState = evaluate('boolean', 'include_toggle_state');
+        if (cast.bonds === undefined || cast.bonds.length === 0) {
+            platform.log.error('Missing bonds in config');
+            return false;
+        }
+        const bondsValid = cast.bonds.map(bond => {
+            return BondConfig.isValid(platform, bond);
+        }).every(v => v === true);
+        return validDimmer && validFanSpeed && validToggleState && bondsValid;
+    }
+    BondPlatformConfig.isValid = isValid;
+})(BondPlatformConfig = exports.BondPlatformConfig || (exports.BondPlatformConfig = {}));
+// eslint-disable-next-line @typescript-eslint/no-namespace
+var BondConfig;
+(function (BondConfig) {
+    function isValid(platform, config) {
+        function evaluate(type, key, value) {
+            if (value === undefined) {
+                platform.log.error(`Missing ${key} in BondConfig.`);
+                return false;
+            }
+            if (typeof (value) !== type) {
+                platform.log.error(`BondConfig ${key} has invalid value: ${value}. Expected ${type}, got ${typeof (value)}.`);
+                return false;
+            }
+            return true;
+        }
+        const validIP = evaluate('string', 'ip_address', config.ip_address);
+        const validToken = evaluate('string', 'token', config.token);
+        let validHideDeviceIds = true;
+        if (config.hide_device_ids !== undefined) {
+            validHideDeviceIds = config.hide_device_ids.map(id => {
+                if (typeof (id) !== 'string') {
+                    platform.log.error(`hide_device_ids contains invalid value: ${id}. Expected string, got ${typeof (id)}.`);
+                    return false;
+                }
+                return true;
+            }).every(v => v === true);
+        }
+        return validIP && validToken && validHideDeviceIds;
+    }
+    BondConfig.isValid = isValid;
+})(BondConfig = exports.BondConfig || (exports.BondConfig = {}));