homebridge-bond 3.2.9

package/dist/platform.js

@@ -0,0 +1,258 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BondPlatform = void 0;
+const Bond_1 = require("./interface/Bond");
+const platformAccessory_1 = require("./platformAccessory");
+const config_1 = require("./interface/config");
+const Device_1 = require("./interface/Device");
+const settings_1 = require("./settings");
+const dgram_1 = __importDefault(require("dgram"));
+class BondPlatform {
+    constructor(log, config, api) {
+        this.log = log;
+        this.config = config;
+        this.api = api;
+        this.Service = this.api.hap.Service;
+        this.Characteristic = this.api.hap.Characteristic;
+        this.UUIDGen = this.api.hap.uuid;
+        this.accessories = [];
+        if (config === null) {
+            this.log.error('No config defined.');
+            return;
+        }
+        if (!config_1.BondPlatformConfig.isValid(this)) {
+            this.log.error(`Config: ${JSON.stringify(config, null, 2)}`);
+            return;
+        }
+        this.log.debug(`Config: ${JSON.stringify(config, null, 2)}`);
+        api.on('didFinishLaunching', () => {
+            // Delaying the initialization of bonds property because we need to
+            // get the device ids before doing anything
+            this.validateBonds();
+        });
+    }
+    // Validate that all of the bonds provided in the config are online and authenticaiton is working
+    validateBonds() {
+        const bonds = Bond_1.Bond.objects(this);
+        const validated = [];
+        Bond_1.Bond.validate(bonds).then(res => {
+            res.forEach(res => {
+                if (res !== undefined) {
+                    validated.push(res);
+                }
+            });
+            this.setupBonds(validated);
+        });
+    }
+    setupBonds(bonds) {
+        if (bonds.length === 0) {
+            this.log.warn('No valid Bonds available.');
+            return;
+        }
+        // const bonds = Bond.objects(this);
+        Bond_1.Bond.updateDeviceIds(bonds).then(() => {
+            this.bonds = bonds;
+            this.log(`${this.accessories.length} cached accessories were loaded`);
+            this.bonds.forEach(bond => {
+                this.getDevices(bond);
+                this.setupBPUP(bond);
+            });
+        });
+    }
+    getDevices(bond) {
+        this.cleanupBondData(bond);
+        this.log(`Getting devices for this Bond (${bond.version.bondid})...`);
+        this.log(`${bond.deviceIds.length} devices were found on this Bond (${bond.version.bondid}).`);
+        const filtered = bond.deviceIds.filter(deviceId => {
+            const accessories = this.accessories.filter(acc => {
+                return acc.context.device.uniqueId === bond.uniqueDeviceId(deviceId);
+            });
+            return accessories.length === 0;
+        });
+        if (filtered.length === 0) {
+            this.log(`No new devices to add for this Bond (${bond.version.bondid}).`);
+            return;
+        }
+        this.log(`Attempting to add ${filtered.length} devices that were not previously added.`);
+        bond.api
+            .getDevices(filtered)
+            .then(devices => {
+            devices.forEach(device => {
+                // Set the unique id
+                device.uniqueId = bond.uniqueDeviceId(device.id);
+                // Set the bond id
+                device.bondId = bond.version.bondid;
+            });
+            this.addAccessories(devices);
+        })
+            .catch(error => {
+            this.log(`Error getting devices: ${error}`);
+        });
+    }
+    cleanupBondData(bond) {
+        // Data cleanup - Make sure all cached devices have uniqueId and bondId on them
+        bond.deviceIds.forEach(deviceId => {
+            this.accessories.forEach(accessory => {
+                // Only run if device does not have uniqueId
+                if (accessory.context.device.uniqueId === undefined
+                    && accessory.context.device.id === deviceId) {
+                    const uniqueId = bond.uniqueDeviceId(deviceId);
+                    this.log.debug(`Updating device data with uniqueId ${uniqueId}`);
+                    accessory.context.device.uniqueId = bond.uniqueDeviceId(deviceId);
+                    accessory.context.device.bondId = bond.version.bondid;
+                }
+            });
+        });
+    }
+    addAccessories(devices) {
+        devices.forEach(device => {
+            this.addAccessory(device);
+        });
+    }
+    // Accessory
+    /**
+     * Add a new accessory that hasn't been added before.
+     */
+    addAccessory(device) {
+        const bond = this.bondForDevice(device);
+        // Make sure Bond exists
+        if (bond === undefined) {
+            this.log(`[${device.name}] Bond does not exist for device id: ${device.id}.`);
+            return;
+        }
+        // Make sure device shouldn't be excluded
+        if ((bond.config.hide_device_ids !== undefined
+            && bond.config.hide_device_ids.includes(device.id))) {
+            this.log(`[${device.name}] Excluding ${device.id}.`);
+            return;
+        }
+        // Make sure device has supported actions
+        if (!Device_1.Device.isSupported(device)) {
+            this.log(`[${device.name}] Device has no supported actions.`);
+            return;
+        }
+        const uuid = this.UUIDGen.generate(device.uniqueId);
+        if (this.accessoryAdded(uuid)) {
+            this.log(`[${device.name}] Accessory already added.`);
+            return;
+        }
+        const displayName = Device_1.Device.displayName(device);
+        const accessory = new this.api.platformAccessory(`${displayName}`, uuid);
+        accessory.context.device = device;
+        this.create(accessory);
+        this.api.registerPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
+        this.accessories.push(accessory);
+        this.log(`Adding Accessory ${accessory.displayName}`);
+        this.log.debug(`Device unique id: ${device.uniqueId}`);
+    }
+    removeAccessory(accessory) {
+        this.log(`Removing Accessory: ${accessory.displayName}`);
+        const index = this.accessories.indexOf(accessory);
+        if (index > -1) {
+            this.accessories.splice(index, 1);
+        }
+        this.api.unregisterPlatformAccessories(settings_1.PLUGIN_NAME, settings_1.PLATFORM_NAME, [accessory]);
+    }
+    configureAccessory(accessory) {
+        if (this.config === null || this.config.bonds === undefined) {
+            return;
+        }
+        this.accessories.push(accessory);
+        // If bonds hasn't been initilized, attempt to configure the accessory
+        // after a delay
+        if (this.bonds) {
+            this.log(`Configuring Accessory: ${accessory.displayName}`);
+            this.create(accessory);
+        }
+        else {
+            const that = this;
+            const timer = setInterval(() => {
+                if (this.bonds) {
+                    that.log(`Configuring Accessory: ${accessory.displayName}`);
+                    that.create(accessory);
+                    clearInterval(timer);
+                }
+            }, 500);
+        }
+    }
+    create(accessory) {
+        const device = accessory.context.device;
+        const bond = this.bondForDevice(device);
+        if (!bond) {
+            return;
+        }
+        if ((bond.config.hide_device_ids
+            && bond.config.hide_device_ids.includes(device.id))) {
+            this.removeAccessory(accessory);
+            return;
+        }
+        this.logAccessory(accessory, `actions: ${device.actions}`);
+        const bondAccessory = platformAccessory_1.BondAccessory.create(this, accessory, bond);
+        bond.accessories.push(bondAccessory);
+    }
+    setupBPUP(bond) {
+        const PORT = 30007;
+        const HOST = bond.config.ip_address;
+        const message = Buffer.from('');
+        const client = dgram_1.default.createSocket('udp4');
+        const log = this.log;
+        function send() {
+            client.send(message, 0, message.length, PORT, HOST, (err) => {
+                if (err) {
+                    log.error(`Erorr sending UDP message: ${err}`);
+                    throw err;
+                }
+                log.debug(`UDP message sent to ${HOST}:${PORT}`);
+            });
+        }
+        send();
+        // From Bond API Docs: The client should continue to send the Keep-Alive datagram on 
+        // the same socket every 60 seconds to keep the connection active.
+        setInterval(send, 1000 * 60);
+        client.on('message', (message, remote) => {
+            const msg = message.toString().trim();
+            const packet = JSON.parse(msg);
+            log.debug(`UDP Message received from ${remote.address}:${remote.port} - ${msg}`);
+            bond.receivedBPUPPacket(packet);
+        });
+        client.on('close', () => {
+            this.log('Connection closed');
+        });
+    }
+    bondForDevice(device) {
+        if (this.bonds) {
+            const bond = this.bonds.find(x => x.version.bondid === device.bondId && x.deviceIds.includes(device.id));
+            if (bond === undefined) {
+                this.log.error(`No Bond found for Device: ${device.name}.
+          This Device may have been removed from your Bond but still exists in cachedAccessories.`);
+            }
+            return bond;
+        }
+        else {
+            this.log.error('config.bonds is not defined');
+        }
+    }
+    // Helper Methods
+    accessoryAdded(uuid) {
+        const accessories = this.accessories.filter(acc => {
+            return acc.UUID === uuid;
+        });
+        return accessories.length > 0;
+    }
+    debug(accessory, message) {
+        const device = accessory.context.device;
+        this.log.debug(`[${device.name}] ${message}`);
+    }
+    logAccessory(accessory, message) {
+        const device = accessory.context.device;
+        this.log(`[${device.name}] ${message}`);
+    }
+    error(accessory, message) {
+        const device = accessory.context.device;
+        this.log.error(`[${device.name}] ${message}`);
+    }
+}
+exports.BondPlatform = BondPlatform;

package/dist/platformAccessory.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BondAccessory = void 0;
+const CeilingFanAccessory_1 = require("./accessories/CeilingFanAccessory");
+const DeviceType_1 = require("./enum/DeviceType");
+const FireplaceAccessory_1 = require("./accessories/FireplaceAccessory");
+const GenericAccessory_1 = require("./accessories/GenericAccessory");
+const LightAccessory_1 = require("./accessories/LightAccessory");
+const ShadesAccessory_1 = require("./accessories/ShadesAccessory");
+// eslint-disable-next-line @typescript-eslint/no-namespace
+var BondAccessory;
+(function (BondAccessory) {
+    function create(platform, accessory, bond) {
+        var _a;
+        const device = accessory.context.device;
+        const service = accessory.getService(platform.Service.AccessoryInformation);
+        service
+            .setCharacteristic(platform.Characteristic.Manufacturer, (_a = bond.version.make) !== null && _a !== void 0 ? _a : `Bond (${bond.version.target})`)
+            // FirmwareRevision only supports semantic versioning, so the 'v' in the firmware version needs to be dropped
+            .setCharacteristic(platform.Characteristic.FirmwareRevision, bond.version.fw_ver.replace('v', ''))
+            // SerialNumber must be at least 2 characters. Use uniqueId to prevent warnings.
+            .setCharacteristic(platform.Characteristic.SerialNumber, device.uniqueId);
+        if (bond.version.model) {
+            service
+                .setCharacteristic(platform.Characteristic.Model, bond.version.model);
+        }
+        if (bond.version.mcu_ver) {
+            service
+                .setCharacteristic(platform.Characteristic.HardwareRevision, bond.version.mcu_ver);
+        }
+        switch (device.type) {
+            case DeviceType_1.DeviceType.CeilingFan:
+                return new CeilingFanAccessory_1.CeilingFanAccessory(platform, accessory, bond);
+            case DeviceType_1.DeviceType.Generic:
+                return new GenericAccessory_1.GenericAccessory(platform, accessory, bond);
+            case DeviceType_1.DeviceType.Fireplace:
+                return new FireplaceAccessory_1.FireplaceAccessory(platform, accessory, bond);
+            case DeviceType_1.DeviceType.Shades:
+                return new ShadesAccessory_1.ShadesAccessory(platform, accessory, bond);
+            case DeviceType_1.DeviceType.Light:
+                return new LightAccessory_1.LightAccessory(platform, accessory, bond);
+            default: {
+                throw 'Invalid Device Type';
+            }
+        }
+    }
+    BondAccessory.create = create;
+})(BondAccessory = exports.BondAccessory || (exports.BondAccessory = {}));

package/dist/settings.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PLUGIN_NAME = exports.PLATFORM_NAME = void 0;
+/**
+ * This is the name of the platform that users will use to register the plugin in the Homebridge config.json
+ */
+exports.PLATFORM_NAME = 'Bond';
+/**
+ * This must match the name of your plugin as defined the package.json
+ */
+exports.PLUGIN_NAME = 'homebridge-bond';

package/global.d.ts

@@ -0,0 +1 @@
+declare module 'biguint-format';

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "homebridge-bond",
+  "version": "3.2.9",
+  "description": "A homebridge plugin to control your Bond devices over the v2 API.",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "scripts": {
+    "lint": "eslint src/**.ts",
+    "watch": "npm run build && npm link && nodemon",
+    "dev": "tsc --watch & nodemon dist",
+    "build": "rimraf ./dist && tsc -p tsconfig-build.json",
+    "prepublishOnly": "npm run lint && npm run build",
+    "test": "mocha -r ts-node/register tests/**/*.spec.ts",
+    "coverage": "nyc -r lcov -e .ts -x \"*.spec.ts\" npm run test"
+  },
+  "keywords": [
+    "homebridge-plugin",
+    "bond",
+    "bond-home",
+    "rf",
+    "ir"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/aarons22/homebridge-bond.git"
+  },
+  "bugs": {
+    "url": "http://github.com/aarons22/homebridge-bond/issues"
+  },
+  "engines": {
+    "node": ">=10.17.0",
+    "homebridge": ">=1.3.0"
+  },
+  "devDependencies": {
+    "@types/chai": "^4.2.14",
+    "@types/flake-idgen": "^0.1.30",
+    "@types/mocha": "^8.2.0",
+    "@types/node": "^14.14.31",
+    "@typescript-eslint/eslint-plugin": "^4.18.0",
+    "@typescript-eslint/parser": "^4.18.0",
+    "chai": "^4.2.0",
+    "eslint": "^7.22.0",
+    "homebridge": "^1.3.1",
+    "mocha": "^9.1.2",
+    "nodemon": "^2.0.7",
+    "nyc": "^15.1.0",
+    "rimraf": "^3.0.2",
+    "ts-node": "^9.1.1",
+    "typescript": "^4.2.2"
+  },
+  "dependencies": {
+    "axios": "^0.21.4",
+    "axios-retry": "^3.1.8",
+    "biguint-format": "^1.0.2",
+    "flake-idgen": "^1.4.0"
+  },
+  "homepage": "https://github.com/aarons22/homebridge-bond#readme",
+  "author": "Aaron Sapp"
+}

package/tests/device.spec.ts

@@ -0,0 +1,263 @@
+import { expect } from 'chai';
+import 'mocha';
+import { Action } from '../src/enum/Action';
+import { DeviceType } from '../src/enum/DeviceType';
+import { Device } from '../src/interface/Device';
+import { DeviceFactory } from './factories/device';
+
+describe('displayName', () => {
+  it('is correct', () => {
+    const device = DeviceFactory.createDevice();
+    expect(Device.displayName(device)).equal('location name');
+  }); 
+});
+
+describe('isSupported', () => {
+  it('ceiling fan', () => {
+    const device = DeviceFactory.createDevice({ type: DeviceType.CeilingFan });
+    expect(Device.isSupported(device)).equal(true);
+  });
+  
+  it('shades', () => {
+    const device = DeviceFactory.createDevice({ type: DeviceType.Shades });
+    expect(Device.isSupported(device)).equal(true);
+  });
+
+  it('generic', () => {
+    const device = DeviceFactory.createDevice({ type: DeviceType.Generic });
+    expect(Device.isSupported(device)).equal(true);
+  });
+
+  it('fireplace', () => {
+    const device = DeviceFactory.createDevice({ type: DeviceType.Fireplace });
+    expect(Device.isSupported(device)).equal(true);
+  });
+
+  it('light', () => {
+    const device = DeviceFactory.createDevice({ type: DeviceType.Light });
+    expect(Device.isSupported(device)).equal(true);
+  }); 
+});
+
+describe('HasDimmer', () => {
+  it('has dimmer', () => {
+    const device = DeviceFactory.createDevice({ actions: [Action.Stop, Action.StartDimmer] });
+    expect(Device.HasDimmer(device)).equal(true);
+  });
+  
+  it('does not have dimmer', () => {
+    const device = DeviceFactory.createDevice({ actions: [Action.Stop] });
+    expect(Device.HasDimmer(device)).equal(false);
+  });
+});
+
+describe('HasSeparateDimmers', () => {
+  it('has dimmer', () => {
+    const device = DeviceFactory.createDevice({ actions: [Action.Stop, Action.StartIncreasingBrightness, Action.StartDecreasingBrightness] });
+    expect(Device.HasSeparateDimmers(device)).equal(true);
+  });
+  
+  it('does not have separate dimmers', () => {
+    const device = DeviceFactory.createDevice({ actions: [Action.Stop] });
+    expect(Device.HasSeparateDimmers(device)).equal(false);
+  });
+});
+
+describe('CFhasLightbulb', () => {
+  it('has lightbulb', () => {
+    const device = DeviceFactory.createDevice({ actions: [Action.Stop, Action.ToggleLight] });
+    expect(Device.CFhasLightbulb(device)).equal(true);
+  });
+  
+  it('does not have lightbulb', () => {
+    const device = DeviceFactory.createDevice({ actions: [Action.Stop] });
+    expect(Device.CFhasLightbulb(device)).equal(false);
+  });
+});
+
+describe('CFhasUpDownLight', () => {
+  it('has up down light', () => {
+    const device = DeviceFactory.createDevice({ actions: [Action.Stop, Action.ToggleUpLight, Action.ToggleDownLight] });
+    expect(Device.CFhasUpDownLight(device)).equal(true);
+  });
+  
+  it('does not have up down light', () => {
+    const device = DeviceFactory.createDevice({ actions: [Action.Stop] });
+    expect(Device.CFhasUpDownLight(device)).equal(false);
+  });
+});
+
+describe('canSetSpeed', () => {
+  it('can set speed', () => {
+    const device = DeviceFactory.createDevice({ 
+      actions: [Action.Stop, Action.SetSpeed],
+      maxSpeed: 1,
+    });
+    expect(Device.canSetSpeed(device)).equal(true);
+  });
+  
+  it('does not have set speed', () => {
+    const device = DeviceFactory.createDevice({ 
+      actions: [Action.Stop],
+      maxSpeed: 1,
+    });
+    expect(Device.canSetSpeed(device)).equal(false);
+  });
+
+  it('does not have max speed', () => {
+    const device = DeviceFactory.createDevice({ 
+      actions: [Action.Stop, Action.SetSpeed],
+    });
+    expect(Device.canSetSpeed(device)).equal(false);
+  });
+});
+
+describe('canIncreaseDecreaseSpeed', () => {
+  it('can increase and decrease speed', () => {
+    const device = DeviceFactory.createDevice({ actions: [Action.Stop, Action.IncreaseSpeed, Action.DecreaseSpeed] });
+    expect(Device.canIncreaseDecreaseSpeed(device)).equal(true);
+  });
+  
+  it('cannnot increase and decrease speed', () => {
+    const device = DeviceFactory.createDevice({ actions: [Action.Stop] });
+    expect(Device.canIncreaseDecreaseSpeed(device)).equal(false);
+  });
+});
+
+describe('hasOffOn', () => {
+  it('has off on', () => {
+    const device = DeviceFactory.createDevice({ actions: [Action.Stop, Action.TurnOff, Action.TurnOn] });
+    expect(Device.hasOffOn(device)).equal(true);
+  });
+  
+  it('does not have off on', () => {
+    const device = DeviceFactory.createDevice({ actions: [Action.Stop] });
+    expect(Device.hasOffOn(device)).equal(false);
+  });
+});
+
+describe('hasReverseSwitch', () => {
+  it('has reverse switch', () => {
+    const device = DeviceFactory.createDevice({ actions: [Action.Stop, Action.ToggleDirection] });
+    expect(Device.hasReverseSwitch(device)).equal(true);
+  });
+  
+  it('does not have reverse switch', () => {
+    const device = DeviceFactory.createDevice({ actions: [Action.Stop] });
+    expect(Device.hasReverseSwitch(device)).equal(false);
+  });
+});
+
+describe('GXhasToggle', () => {
+  it('has toggle', () => {
+    const device = DeviceFactory.createDevice({ actions: [Action.Stop, Action.TogglePower] });
+    expect(Device.GXhasToggle(device)).equal(true);
+  });
+  
+  it('does not have toggle', () => {
+    const device = DeviceFactory.createDevice({ actions: [Action.Stop] });
+    expect(Device.GXhasToggle(device)).equal(false);
+  });
+});
+
+describe('FPhasToggle', () => {
+  it('has toggle', () => {
+    const device = DeviceFactory.createDevice({ actions: [Action.Stop, Action.TogglePower] });
+    expect(Device.FPhasToggle(device)).equal(true);
+  });
+  
+  it('does not have toggle', () => {
+    const device = DeviceFactory.createDevice({ actions: [Action.Stop] });
+    expect(Device.FPhasToggle(device)).equal(false);
+  });
+});
+
+describe('FPhasFlame', () => {
+  it('has flame and toggle power', () => {
+    const device = DeviceFactory.createDevice({ actions: [Action.Stop, Action.SetFlame, Action.TogglePower] });
+    expect(Device.FPhasFlame(device)).equal(true);
+  });
+  
+  it('does not have flame and toggle power', () => {
+    const device = DeviceFactory.createDevice({ actions: [Action.TogglePower] });
+    expect(Device.FPhasFlame(device)).equal(false);
+  });
+});
+
+describe('MShasToggle', () => {
+  it('has toggle', () => {
+    const device = DeviceFactory.createDevice({ actions: [Action.Stop, Action.ToggleOpen] });
+    expect(Device.MShasToggle(device)).equal(true);
+  });
+  
+  it('does not have toggle', () => {
+    const device = DeviceFactory.createDevice({ actions: [Action.Stop] });
+    expect(Device.MShasToggle(device)).equal(false);
+  });
+});
+
+describe('MShasPreset', () => {
+  it('has preset', () => {
+    const device = DeviceFactory.createDevice({ actions: [Action.Stop, Action.Preset] });
+    expect(Device.MShasPreset(device)).equal(true);
+  });
+  
+  it('does not have preset', () => {
+    const device = DeviceFactory.createDevice({ actions: [Action.Stop] });
+    expect(Device.MShasPreset(device)).equal(false);
+  });
+});
+
+describe('LThasLightbulb', () => {
+  it('has lightbulb', () => {
+    const device = DeviceFactory.createDevice({ actions: [Action.Stop, Action.ToggleLight] });
+    expect(Device.LThasLightbulb(device)).equal(true);
+  });
+  
+  it('does not have lightbulb', () => {
+    const device = DeviceFactory.createDevice({ actions: [Action.Stop] });
+    expect(Device.LThasLightbulb(device)).equal(false);
+  });
+});
+
+describe('LThasBrightness', () => {
+  it('has brightness', () => {
+    const device = DeviceFactory.createDevice({ actions: [Action.Stop, Action.SetBrightness, Action.TurnLightOff] });
+    expect(Device.LThasBrightness(device)).equal(true);
+  });
+  
+  it('does not have brightness', () => {
+    const device = DeviceFactory.createDevice({ actions: [Action.Stop] });
+    expect(Device.LThasBrightness(device)).equal(false);
+  });
+});
+
+describe('fanSpeeds', () => {
+  context('has commands', () => {
+    it('returns correct values', () => {
+      const device = DeviceFactory.createFanWithSpeeds([1,2,3]);
+      expect(Device.fanSpeeds(device)).to.deep.equal([1,2,3]);
+    });
+
+    it('returns correct values', () => {
+      const device = DeviceFactory.createFanWithSpeeds([1,2,4]);
+      expect(Device.fanSpeeds(device)).to.deep.equal([1,2,4]);
+    });
+  });
+
+  context('does not have commands', () => {
+    context('has max speed', () => {
+      it('returns correct values', () => {
+        const device = DeviceFactory.createDevice({maxSpeed: 6});
+        expect(Device.fanSpeeds(device)).to.deep.equal([1,2,3,4,5,6]);
+      });
+    });
+
+    context('does not have max speed', () => {
+      it('returns empty array', () => {
+        const device = DeviceFactory.createDevice();
+        expect(Device.fanSpeeds(device)).to.deep.equal([]);
+      });
+    });
+  });
+});