Files
flic2hass/lib.js
T
2025-11-15 22:57:12 -05:00

2061 lines
76 KiB
JavaScript

'use strict';
var ir = require('ir');
var datastore = require('datastore');
var net = require('net');
var flichub = require('flicapp');
var hubinfo = require('hubinfo');
var buttonModule = require('buttons');
function makeLogger(prefix) {
var debugMode = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
return {
info: function info() {
for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
args[_key] = arguments[_key];
}
console.log("".concat(prefix, "|INFO| ").concat(args.map(String).join(" ")));
},
error: function error() {
for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
args[_key] = arguments[_key];
}
console.log("".concat(prefix, "|ERROR| ").concat(args.map(String).join(" ")));
},
debug: function debug() {
for(var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++){
args[_key] = arguments[_key];
}
if (debugMode) {
console.log("".concat(prefix, "|DEBUG| ").concat(args.map(String).join(" ")));
}
}
};
}
function _define_property$7(obj, key, value) {
if (key in obj) {
Object.defineProperty(obj, key, {
value: value,
enumerable: true,
configurable: true,
writable: true
});
} else {
obj[key] = value;
}
return obj;
}
function _object_spread$5(target) {
for(var i = 1; i < arguments.length; i++){
var source = arguments[i] != null ? arguments[i] : {};
var ownKeys = Object.keys(source);
if (typeof Object.getOwnPropertySymbols === "function") {
ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
return Object.getOwnPropertyDescriptor(source, sym).enumerable;
}));
}
ownKeys.forEach(function(key) {
_define_property$7(target, key, source[key]);
});
}
return target;
}
function ownKeys$3(object, enumerableOnly) {
var keys = Object.keys(object);
if (Object.getOwnPropertySymbols) {
var symbols = Object.getOwnPropertySymbols(object);
keys.push.apply(keys, symbols);
}
return keys;
}
function _object_spread_props$3(target, source) {
source = source != null ? source : {};
if (Object.getOwnPropertyDescriptors) {
Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
} else {
ownKeys$3(Object(source)).forEach(function(key) {
Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
});
}
return target;
}
var makeOptions$3 = function(opt) {
return _object_spread_props$3(_object_spread$5({
debug: false
}, opt), {
topics: _object_spread$5({
homeassistant: "homeassistant",
flic: "flic"
}, opt.topics)
});
};
function _define_property$6(obj, key, value) {
if (key in obj) {
Object.defineProperty(obj, key, {
value: value,
enumerable: true,
configurable: true,
writable: true
});
} else {
obj[key] = value;
}
return obj;
}
function _object_spread$4(target) {
for(var i = 1; i < arguments.length; i++){
var source = arguments[i] != null ? arguments[i] : {};
var ownKeys = Object.keys(source);
if (typeof Object.getOwnPropertySymbols === "function") {
ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
return Object.getOwnPropertyDescriptor(source, sym).enumerable;
}));
}
ownKeys.forEach(function(key) {
_define_property$6(target, key, source[key]);
});
}
return target;
}
function ownKeys$2(object, enumerableOnly) {
var keys = Object.keys(object);
if (Object.getOwnPropertySymbols) {
var symbols = Object.getOwnPropertySymbols(object);
keys.push.apply(keys, symbols);
}
return keys;
}
function _object_spread_props$2(target, source) {
source = source != null ? source : {};
if (Object.getOwnPropertyDescriptors) {
Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
} else {
ownKeys$2(Object(source)).forEach(function(key) {
Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
});
}
return target;
}
function makeHAmqtt(mqttServer) {
var _options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
var options = makeOptions$3(_options);
var logger = makeLogger("mqtt:ha", options.debug);
logger.info("starting...", JSON.stringify(options, null, 4));
var genFlicPrefix = function(nodeId, objectId) {
return "".concat(options.topics.flic, "/").concat(nodeId, "/").concat(objectId);
};
var genFlicPrefixObject = function(nodeId, objectId) {
return {
nodeId: nodeId,
objectId: objectId,
mqttPrefix: genFlicPrefix(nodeId, objectId)
};
};
var genHAPrefix = function(component, nodeId, objectId) {
return "".concat(options.topics.homeassistant, "/").concat(component, "/").concat(nodeId, "/").concat(objectId);
};
var publishStateFromObject = function(obj, state) {
var opt = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
mqttServer.publish(obj.mqttPrefix, state + "", opt);
logger.debug(JSON.stringify({
obj: obj,
state: state,
opt: opt
}));
};
var publishState = function(nodeId, objectId, state) {
var opt = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : {};
var topic = genFlicPrefix(nodeId, objectId);
mqttServer.publish(topic, state + "", opt);
logger.debug(topic, state, JSON.stringify(opt));
};
var registerEntity = function(name, component, nodeId, objectId, device) {
var additionalProps = arguments.length > 5 && arguments[5] !== void 0 ? arguments[5] : {};
var configtopic = genHAPrefix(component, nodeId, objectId) + "/config";
if (component === "device_automation") {
additionalProps.topic = genFlicPrefix(nodeId, objectId);
} else {
additionalProps.state_topic = genFlicPrefix(nodeId, objectId);
}
var configObj = _object_spread_props$2(_object_spread$4({
name: name
}, additionalProps), {
unique_id: "Flic_".concat(nodeId, "_").concat(objectId),
device: device
});
mqttServer.publish(configtopic, JSON.stringify(configObj), {
retain: true
});
logger.debug(configtopic, JSON.stringify(configObj, null, 4));
};
var deregisterEntity = function(component, nodeId, objectId) {
var configtopic = genHAPrefix(component, nodeId, objectId) + "/config";
// mqttServer.publish(configtopic, null, { retain: false });
logger.debug(configtopic, null);
};
var startLifeLine = function(name, nodeId, haDevice) {
var topic = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : "lifeline";
registerEntity(name, "binary_sensor", nodeId, topic, haDevice, {
device_class: "connectivity",
expire_after: 5,
off_delay: 3,
entity_category: "diagnostic",
payload_available: "ON",
payload_not_available: "OFF"
});
setInterval(function() {
publishState(nodeId, topic, "ON");
}, 2500);
};
return {
deregisterEntity: deregisterEntity,
registerEntity: registerEntity,
publishState: publishState,
publishStateFromObject: publishStateFromObject,
genFlicPrefix: genFlicPrefix,
genFlicPrefixObject: genFlicPrefixObject,
startLifeLine: startLifeLine
};
}
function _define_property$5(obj, key, value) {
if (key in obj) {
Object.defineProperty(obj, key, {
value: value,
enumerable: true,
configurable: true,
writable: true
});
} else {
obj[key] = value;
}
return obj;
}
function _object_spread$3(target) {
for(var i = 1; i < arguments.length; i++){
var source = arguments[i] != null ? arguments[i] : {};
var ownKeys = Object.keys(source);
if (typeof Object.getOwnPropertySymbols === "function") {
ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
return Object.getOwnPropertyDescriptor(source, sym).enumerable;
}));
}
ownKeys.forEach(function(key) {
_define_property$5(target, key, source[key]);
});
}
return target;
}
var NODE_ID$1 = "FlicHubIR";
var convertUint32Array2Str = function(arr) {
var outStr = [];
for(var i = 0; i < arr.length; i++){
outStr.push(arr[i].toString(32));
}
return outStr.join("_");
};
var convertStr2Uint32Array = function(s) {
var a = s.split("_");
return new Uint32Array(a.slice(0, a.length - 2).map(function(v) {
return parseInt(v, 32);
}));
};
var makeOptions$2 = function(opt) {
return _object_spread$3({
debug: false,
uniqueId: "0"
}, opt);
};
var getConstants$2 = function(ha, options) {
var nodeId = "".concat(NODE_ID$1).concat(options.uniqueId);
var LIFELINE_SIGNAL = ha.genFlicPrefixObject(nodeId, "lifeline");
var RECORD_SIGNAL = ha.genFlicPrefixObject(nodeId, "record");
var RECORD_SIGNAL_SET = ha.genFlicPrefixObject(nodeId, "record/set");
var PLAY_SIGNAL = ha.genFlicPrefixObject(nodeId, "play");
var PLAY_SIGNAL_SET = ha.genFlicPrefixObject(nodeId, "play/set");
var RECORDED_SIGNALS = ha.genFlicPrefixObject(nodeId, "rsignals");
var RECORDED_SIGNALS_CMD = ha.genFlicPrefixObject(nodeId, "rsignals/cmd");
var DELETE_SIGNAL = ha.genFlicPrefixObject(nodeId, "delsignals");
var DELETE_SIGNAL_CMD = ha.genFlicPrefixObject(nodeId, "delsignals/cmd");
var availability = [
{
payload_available: "ON",
payload_not_available: "unavailable",
topic: LIFELINE_SIGNAL.mqttPrefix
}
];
return {
NODE_ID: nodeId,
LIFELINE_SIGNAL: LIFELINE_SIGNAL,
RECORD_SIGNAL: RECORD_SIGNAL,
RECORD_SIGNAL_SET: RECORD_SIGNAL_SET,
RECORDED_SIGNALS: RECORDED_SIGNALS,
RECORDED_SIGNALS_CMD: RECORDED_SIGNALS_CMD,
PLAY_SIGNAL: PLAY_SIGNAL,
PLAY_SIGNAL_SET: PLAY_SIGNAL_SET,
DELETE_SIGNAL: DELETE_SIGNAL,
DELETE_SIGNAL_CMD: DELETE_SIGNAL_CMD,
set_topics: [
RECORD_SIGNAL_SET,
RECORDED_SIGNALS_CMD,
PLAY_SIGNAL_SET,
DELETE_SIGNAL_CMD
].map(function(x) {
return x.mqttPrefix;
}),
availability: availability
};
};
var homeAutomationWords = [
"home",
"hub",
"plug",
"bulb",
"lock",
"door",
"gate",
"bell",
"cam",
"nest",
"ring",
"alex",
"echo",
"siri",
"gove",
"hue",
"wemo",
"sonos",
"arlo",
"wyze",
"zigb",
"zway",
"mqtt",
"node",
"iftt",
"zap",
"temp",
"heat",
"cool",
"fan",
"vent",
"ac",
"wifi",
"ble",
"zwav",
"lora",
"mesh",
"edge",
"cloud",
"api",
"app",
"ios",
"droid",
"voice",
"tap",
"swipe",
"scene",
"rule",
"auto",
"mode",
"away",
"sleep",
"wake",
"light",
"dim",
"on",
"off",
"toggle",
"timer",
"schedule",
"sensor",
"motion",
"open",
"close",
"leak",
"smoke",
"co2",
"air",
"humid",
"lux",
"rgb",
"cct",
"tune",
"group",
"zone",
"room",
"floor",
"alarm",
"siren",
"arm",
"disarm",
"panic",
"geo",
"fence",
"dash",
"widget",
"ui",
"theme",
"dark",
"log",
"event",
"alert",
"push",
"sms",
"email",
"web",
"hook",
"rest",
"grpc",
"mqtt"
];
function generateSequence(n) {
var words = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : null, sep = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "-";
words = words || homeAutomationWords;
var result = [];
for(var i = 0; i < n; i++){
var randomIndex = Math.floor(Math.random() * words.length);
result.push(words[randomIndex]);
}
return result.join(sep);
}
var generateRandomKeyNotInList = function(l) {
var name = generateSequence(5);
while(l.indexOf(name) !== -1){
name = generateSequence(5);
}
return name;
};
var registerEntities$1 = function(ha, haDevice, constants) {
var NODE_ID = constants.NODE_ID, LIFELINE_SIGNAL = constants.LIFELINE_SIGNAL, RECORD_SIGNAL = constants.RECORD_SIGNAL, RECORD_SIGNAL_SET = constants.RECORD_SIGNAL_SET, PLAY_SIGNAL = constants.PLAY_SIGNAL, PLAY_SIGNAL_SET = constants.PLAY_SIGNAL_SET, DELETE_SIGNAL = constants.DELETE_SIGNAL, DELETE_SIGNAL_CMD = constants.DELETE_SIGNAL_CMD, availability = constants.availability;
ha.startLifeLine("IR Connnected", NODE_ID, haDevice, LIFELINE_SIGNAL.objectId);
ha.registerEntity("Record Signal", "switch", NODE_ID, RECORD_SIGNAL.objectId, haDevice, {
icon: "mdi:record-rec",
command_topic: RECORD_SIGNAL_SET.mqttPrefix,
device_class: "switch",
availability: availability
});
ha.registerEntity("Play Signal", "button", NODE_ID, PLAY_SIGNAL.objectId, haDevice, {
icon: "mdi:play",
command_topic: PLAY_SIGNAL_SET.mqttPrefix,
availability: availability
});
ha.registerEntity("Delete Signal", "button", NODE_ID, DELETE_SIGNAL.objectId, haDevice, {
icon: "mdi:delete",
command_topic: DELETE_SIGNAL_CMD.mqttPrefix,
availability: availability
});
};
var registerSelect = function(ha, haDevice, state, param) {
var NODE_ID = param.NODE_ID, RECORD_SIGNAL = param.RECORD_SIGNAL, RECORDED_SIGNALS_CMD = param.RECORDED_SIGNALS_CMD, availability = param.availability, onDone = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : function() {};
state.signalStore.withDataIndexed(function(data) {
ha.registerEntity("Recorded Signals", "select", NODE_ID, RECORD_SIGNAL.objectId, haDevice, {
command_topic: RECORDED_SIGNALS_CMD.mqttPrefix,
icon: "mdi:broadcast",
max: 500,
availability: availability,
options: data.map(function(param) {
var name = param.name;
return String(name);
})
});
onDone();
});
};
var irMQTTHandler = function(mqtt, ha, nodeId, logger, state, param, reloadSelectableSignals) {
var RECORD_SIGNAL_SET = param.RECORD_SIGNAL_SET, RECORDED_SIGNALS_CMD = param.RECORDED_SIGNALS_CMD, PLAY_SIGNAL_SET = param.PLAY_SIGNAL_SET, DELETE_SIGNAL_CMD = param.DELETE_SIGNAL_CMD, RECORD_SIGNAL = param.RECORD_SIGNAL;
logger.info("Registering ir mqtt handler ".concat(nodeId, " "));
mqtt.on("message", function(topic, message) {
logger.info("message:", JSON.stringify({
topic: topic,
message: message,
state: state
}));
if (topic === RECORD_SIGNAL_SET.mqttPrefix) {
logger.info("IR module is being set to ".concat(message));
if (!state.isRecording()) {
ir.record();
state.setRecordingState(true);
logger.info("Started recording...");
return;
}
if (message === "OFF" && state.isRecording()) {
logger.info("Attempting to stop recording...");
try {
ir.cancelRecord();
state.setRecordingState(false);
logger.info("Recording stopped!");
return;
} catch (err) {
logger.error("Failed to stop record, check you have the latest version of the sdk!");
state.setRecordingState(true);
ha.publishState(nodeId, RECORD_SIGNAL.objectId, "OFF", {
dup: false
});
return;
}
}
logger.info("Doing nothing state.isRecording()=".concat(state.isRecording()));
return;
}
if (topic === RECORDED_SIGNALS_CMD.mqttPrefix) {
logger.info("Updating internal signal state to ".concat(message));
state.signalStore.setSelection(message, function() {});
return;
}
if (topic === PLAY_SIGNAL_SET.mqttPrefix) {
return state.signalStore.withData(function(signals, currentSelection) {
if (currentSelection === null) {
logger.error("currentSelection=".concat(currentSelection, " cannot be played!"));
return;
}
if (currentSelection >= signals.length) {
logger.error("currentSelection=".concat(currentSelection, " >= signals.length=").concat(signals.length, " cannot be played!"));
return;
}
var currentSignal = signals[currentSelection];
var arr = null;
try {
arr = convertStr2Uint32Array(currentSignal);
} catch (err) {
logger.error("invalid string signal set", JSON.stringify(err), err);
return;
}
return ir.play(arr, function(err) {
if (err) {
logger.error("failed to play signal", JSON.stringify(err), err);
} else {
logger.debug("signal played!");
}
});
});
}
if (topic === DELETE_SIGNAL_CMD.mqttPrefix) {
return state.signalStore.removeCurrent(function() {
return reloadSelectableSignals(function() {
return logger.info("Successfully removed Current Selection!");
});
});
}
logger.error("Invalid topic recieved from mqtt ".concat(JSON.stringify({
topic: topic,
message: message
})));
});
};
var handleIREvents = function(ha, logger, nodeId, state, param, reloadSelectableSignals) {
var RECORD_SIGNAL = param.RECORD_SIGNAL, RECORDED_SIGNALS = param.RECORDED_SIGNALS;
ir.on("recordComplete", function(data) {
logger.info("recordComplete", data);
if (data.length === 0) {
logger.error("Failed to record any data");
return;
}
var stringMessage = convertUint32Array2Str(data);
logger.info("recording completed with", JSON.stringify({
stringMessage: stringMessage
}));
state.signalStore.add(stringMessage, function(idx) {
reloadSelectableSignals(function() {
ha.publishState(nodeId, RECORDED_SIGNALS.objectId, String(idx), {
retain: true
});
});
});
state.setRecordingState(false);
ha.publishState(nodeId, RECORD_SIGNAL.objectId, "OFF");
});
};
function _class_call_check$1(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
}
function _defineProperties$1(target, props) {
for(var i = 0; i < props.length; i++){
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
function _create_class$1(Constructor, protoProps, staticProps) {
if (protoProps) _defineProperties$1(Constructor.prototype, protoProps);
return Constructor;
}
function _define_property$4(obj, key, value) {
if (key in obj) {
Object.defineProperty(obj, key, {
value: value,
enumerable: true,
configurable: true,
writable: true
});
} else {
obj[key] = value;
}
return obj;
}
var IRSignalStore = /*#__PURE__*/ function() {
function IRSignalStore(logger) {
var storeCacheKey = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : "flic2hass:ir:signals";
_class_call_check$1(this, IRSignalStore);
_define_property$4(this, "logger", void 0);
_define_property$4(this, "storeCacheKey", void 0);
_define_property$4(this, "internalCacheStore", void 0);
this.logger = logger;
this.storeCacheKey = storeCacheKey;
this.internalCacheStore = null;
this.reloadLocalCache();
}
_create_class$1(IRSignalStore, [
{
key: "reloadLocalCache",
value: function reloadLocalCache() {
var cb = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : function() {};
var _this = this;
this.getValues(function(err, data) {
if (err) {
return cb(err, null);
}
if (data) {
_this.internalCacheStore = data;
return cb(null, data);
}
});
}
},
{
key: "getValues",
value: function getValues(cb) {
var _this = this;
return datastore.get(this.storeCacheKey, function(err, data) {
if (err) {
return cb(err, null);
}
if (!data) {
return cb(null, {
currentSelection: null,
signals: {}
});
}
try {
return cb(null, JSON.parse(data));
} catch (err) {
_this.logger.error("Failed to parse json defaulting to empty -> data=".concat(data, " err=").concat(err));
return cb(null, {
currentSelection: null,
signals: {}
});
}
});
}
},
{
key: "withData",
value: function withData(cb) {
if (this.internalCacheStore) {
cb(this.internalCacheStore["signals"], this.internalCacheStore["currentSelection"]);
} else {
this.reloadLocalCache(function(err, data) {
if (err) {
throw err;
}
if (!data) {
throw new Error("failed to get data");
}
return cb(data["signals"], data["currentSelection"]);
});
}
}
},
{
key: "withDataIndexed",
value: function withDataIndexed(cb) {
this.withData(function(signals, currentSelection) {
cb(Object.keys(signals).map(function(k) {
return {
name: k,
signal: signals[k]
};
}), currentSelection);
});
}
},
{
key: "setSelection",
value: function setSelection(selection, cb) {
var _this = this;
this.withData(function(signals) {
if (signals[selection]) {
_this.persist({
signals: signals,
currentSelection: selection
});
return cb(selection);
}
_this.logger.error("Not setting currentSelection to ".concat(selection, " as data.keys=").concat(Object.keys(signals), ", consider reloading or deleting the entity in home-assistant."));
_this.persist({
signals: signals,
currentSelection: null
});
return cb(null);
});
}
},
{
key: "add",
value: function add(signal, cb) {
var _this = this;
this.withData(function(signals, currentSelection) {
var randomName = generateRandomKeyNotInList(Object.keys(signals));
signals[randomName] = signal;
_this.persist({
signals: signals,
currentSelection: currentSelection
});
cb(randomName);
});
}
},
{
key: "remove",
value: function remove(name, cb) {
var _this = this;
this.withData(function(signals, currentSelection) {
delete signals[name];
_this.persist({
signals: signals,
currentSelection: currentSelection
});
return cb();
});
}
},
{
key: "removeCurrent",
value: function removeCurrent(cb) {
var _this = this;
this.withData(function(signals, currentSelection) {
if (currentSelection === null) {
_this.logger.error("Not removing ".concat(currentSelection, " as it is null, consider reloading or deleting the entity in home-assistant."));
return;
}
delete signals[currentSelection];
_this.persist({
signals: signals,
currentSelection: null
});
return cb();
});
}
},
{
key: "persist",
value: function persist(data) {
this.internalCacheStore = data;
datastore.put(this.storeCacheKey, JSON.stringify(this.internalCacheStore));
}
}
]);
return IRSignalStore;
}();
var makeIRSharedState = function(logger) {
var isRecording = false;
var signalStore = new IRSignalStore(logger);
return {
signalStore: signalStore,
isRecording: function isRecording1() {
return isRecording;
},
setRecordingState: function setRecordingState(newValue) {
isRecording = newValue;
}
};
};
var startIRController = function(ha, mqtt) {
var _options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
var options = makeOptions$2(_options);
var logger = makeLogger("ir", options.debug);
var haDevice = {
name: "IR",
manufacturer: "Flic",
model: "".concat(NODE_ID$1).concat(options.uniqueId),
identifiers: [
"FlicHubIR"
],
configuration_url: "https://hubsdk.flic.io/"
};
var constants = getConstants$2(ha, options);
var nodeId = constants.NODE_ID;
var state = makeIRSharedState(logger);
logger.info("starting...");
logger.debug("setting up entities...");
registerEntities$1(ha, haDevice, constants);
registerSelect(ha, haDevice, state, constants);
logger.debug("setting default states....");
ha.publishState(nodeId, constants.RECORD_SIGNAL.objectId, "OFF");
ha.publishState(nodeId, constants.PLAY_SIGNAL.objectId, "OFF");
logger.debug("registering events");
irMQTTHandler(mqtt, ha, nodeId, logger, state, constants, function(onDone) {
return registerSelect(ha, haDevice, state, constants, onDone);
});
handleIREvents(ha, logger, nodeId, state, constants, function(onDone) {
return registerSelect(ha, haDevice, state, constants, onDone);
});
logger.debug("subscribing to", constants.set_topics);
mqtt.subscribe(constants.set_topics);
logger.info("is up");
};
/** 'private' constants */ var C = {
PROTOCOL_LEVEL: 4,
DEF_PORT: 1883,
DEF_KEEP_ALIVE: 60,
DEF_QOS: 0,
CONNECT_TIMEOUT: 10000,
PING_INTERVAL: 40
};
/** Control packet types */ var TYPE = {
CONNECT: 1,
CONNACK: 2,
PUBLISH: 3,
PUBACK: 4,
PUBREC: 5,
PUBREL: 6,
PUBCOMP: 7,
SUBSCRIBE: 8,
SUBACK: 9,
UNSUBSCRIBE: 10,
UNSUBACK: 11,
PINGREQ: 12,
PINGRESP: 13,
DISCONNECT: 14
};
/**
Return Codes
http://docs.oasis-open.org/mqtt/mqtt/v3.1.1/os/mqtt-v3.1.1-os.html#_Toc385349256
**/ var RETURN_CODES = {
0: "ACCEPTED",
1: "UNACCEPTABLE_PROTOCOL_VERSION",
2: "IDENTIFIER_REJECTED",
3: "SERVER_UNAVAILABLE",
4: "BAD_USER_NAME_OR_PASSWORD",
5: "NOT_AUTHORIZED"
};
/** Generate random UID */ var mqttUid = function() {
function s4() {
var numberstring = Math.floor(1 + Math.random() * 10);
if (numberstring == 10) numberstring = 9;
numberstring = 97 + numberstring;
return numberstring;
}
return function() {
var output = [
0,
12,
s4(),
s4(),
s4(),
s4(),
s4(),
s4(),
s4(),
s4(),
s4(),
s4(),
s4(),
s4()
];
return output;
};
}();
/** MQTT string (length MSB, LSB + data) */ var mqttStr = function(s) {
var payloadarray = [
s.length >> 8,
s.length & 255
];
var i = 2;
var messagearray = s.split("");
for(var j = 0; j < s.length; j++){
var _char = messagearray[j];
var numberrepres = _char.charCodeAt(0);
payloadarray[i] = numberrepres;
i = i + 1;
}
return payloadarray;
};
var getClientId = function(options) {
if (typeof options.client_id == "string") {
return mqttStr(options.client_id);
}
return options.client_id;
};
var setOptionDefaults = function(options) {
return {
port: options.port || C.DEF_PORT,
client_id: options.client_id || mqttUid(),
keep_alive: options.keep_alive || C.DEF_KEEP_ALIVE,
clean_session: options.clean_session || true,
username: options.username,
password: options.password,
protocol_name: options.protocol_name || "MQTT",
protocol_level: options.protocol_level || C.PROTOCOL_LEVEL
};
};
/** MQTT packet length formatter - algorithm from reference docs */ var mqttPacketLength = function(length) {
var encLength = [];
var i = 0;
do {
var encByte = length & 127;
length = length >> 7;
// if there are more data to encode, set the top bit of this byte
if (length > 0) {
encByte += 128;
}
encLength[i] = encByte;
i++;
}while (length > 0);
return encLength;
};
var mqttPacketLengthDec = function(length) {
var bytes = 0;
var decL = 0;
var lb = 0;
do {
lb = length[bytes];
decL |= (lb & 127) << bytes++ * 7;
}while (lb & 128 && bytes < 4);
return {
decLen: decL,
lenBy: bytes
};
};
var createBufferFromArray = function(a) {
if (Buffer.from) {
return Buffer.from(a);
} else {
return new Buffer(a);
}
};
/** MQTT standard packet formatter */ var mqttPacket = function(cmd, variable, payload) {
var cmdAndLengthArray = [
cmd
].concat(mqttPacketLength(variable.length + payload.length));
var headerAndPayloadArray = cmdAndLengthArray.concat(variable).concat(payload);
var messageBuffer = createBufferFromArray(headerAndPayloadArray);
return messageBuffer;
};
/** Get PID from message */ var getPid = function(data) {
return data.slice(0, 2);
};
/** PUBLISH control packet */ var createMqttPublishPacket = function(topic, message, qos, flags, pid) {
var cmd = TYPE.PUBLISH << 4 | qos << 1 | flags;
var variable = mqttStr(topic);
// Packet id must be included for QOS > 0
if (qos > 0) {
var newvariable = variable.concat(pid);
return mqttPacket(cmd, newvariable, message);
} else {
return mqttPacket(cmd, variable, message);
}
};
/** SUBSCRIBE control packet */ var createMqttSubscribePacket = function(topic, qos, pid) {
var cmd = TYPE.SUBSCRIBE << 4 | 2;
var payloadarray = [];
var i = 0;
var messagearray = topic.split("");
for(var j = 0; j < topic.length; j++){
var _char = messagearray[j];
var numberrepres = _char.charCodeAt(0);
payloadarray[i] = numberrepres;
i = i + 1;
}
return mqttPacket(cmd, pid, mqttStr(topic).concat([
qos
]));
};
function _array_like_to_array$1(arr, len) {
if (len == null || len > arr.length) len = arr.length;
for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
return arr2;
}
function _array_without_holes$1(arr) {
if (Array.isArray(arr)) return _array_like_to_array$1(arr);
}
function _class_call_check(instance, Constructor) {
if (!(instance instanceof Constructor)) {
throw new TypeError("Cannot call a class as a function");
}
}
function _defineProperties(target, props) {
for(var i = 0; i < props.length; i++){
var descriptor = props[i];
descriptor.enumerable = descriptor.enumerable || false;
descriptor.configurable = true;
if ("value" in descriptor) descriptor.writable = true;
Object.defineProperty(target, descriptor.key, descriptor);
}
}
function _create_class(Constructor, protoProps, staticProps) {
if (protoProps) _defineProperties(Constructor.prototype, protoProps);
return Constructor;
}
function _define_property$3(obj, key, value) {
if (key in obj) {
Object.defineProperty(obj, key, {
value: value,
enumerable: true,
configurable: true,
writable: true
});
} else {
obj[key] = value;
}
return obj;
}
function _iterable_to_array$1(iter) {
if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
}
function _non_iterable_spread$1() {
throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _to_consumable_array$1(arr) {
return _array_without_holes$1(arr) || _iterable_to_array$1(arr) || _unsupported_iterable_to_array$1(arr) || _non_iterable_spread$1();
}
function _unsupported_iterable_to_array$1(o, minLen) {
if (!o) return;
if (typeof o === "string") return _array_like_to_array$1(o, minLen);
var n = Object.prototype.toString.call(o).slice(8, -1);
if (n === "Object" && o.constructor) n = o.constructor.name;
if (n === "Map" || n === "Set") return Array.from(n);
if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array$1(o, minLen);
}
var FlicMQTT = /*#__PURE__*/ function() {
function FlicMQTT(server, _options) {
_class_call_check(this, FlicMQTT);
_define_property$3(this, "server", void 0);
_define_property$3(this, "options", void 0);
_define_property$3(this, "clientId", void 0);
_define_property$3(this, "connected", void 0);
_define_property$3(this, "pingInterval", void 0);
_define_property$3(this, "username", void 0);
_define_property$3(this, "password", void 0);
_define_property$3(this, "client", void 0);
_define_property$3(this, "__listeners", void 0);
_define_property$3(this, "pakId", void 0);
_define_property$3(this, "partData", void 0);
_define_property$3(this, "ctimo", void 0);
_define_property$3(this, "pintr", void 0);
this.server = server;
this.connected = false;
this.username = null;
this.password = null;
this.client = null;
this.__listeners = {
close: [],
connected: [],
connect: [],
disconnected: [],
end: [],
error: [],
data: [],
publish: [],
message: [],
puback: [],
pubcomp: [],
subscribed: [],
unsubscribed: [],
subscribed_fail: [],
ping_reply: []
};
this.pakId = Math.floor(Math.random() * 65534);
this.partData = [];
this.ctimo = null;
this.pintr = null;
this.options = setOptionDefaults(_options);
this.clientId = getClientId(this.options);
if (this.options.username) {
this.username = mqttStr(this.options.username);
}
if (this.options.password) {
this.password = mqttStr(this.options.password);
}
this.pingInterval = this.options.keep_alive < C.PING_INTERVAL ? this.options.keep_alive - 5 : C.PING_INTERVAL;
}
_create_class(FlicMQTT, [
{
key: "isConnected",
value: function isConnected() {
return this.client !== null;
}
},
{
key: "on",
value: function on(type, fn) {
if (!this.__listeners[type]) {
this.__listeners[type] = [];
}
this.__listeners[type].push(fn);
}
},
{
key: "emit",
value: function emit(type) {
for(var _len = arguments.length, data = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
data[_key - 1] = arguments[_key];
}
if (this.__listeners[type]) {
this.__listeners[type].map(function(fn) {
fn.apply(void 0, _to_consumable_array$1(data));
});
}
}
},
{
key: "mqttPid",
value: function mqttPid() {
this.pakId = this.pakId > 65534 ? 1 : ++this.pakId;
return [
this.pakId >> 8,
this.pakId & 0xff
];
}
},
{
key: "connect",
value: function connect() {
console.log("Connecting..." + JSON.stringify({
connected: this.connected
}));
if (this.connected) {
return;
}
var mqo = this;
try {
var client = this.client = net.createConnection({
host: this.server,
port: this.options.port
}, function() {
// write connection message
var teststring = mqo.mqttConnect(!!mqo.clientId);
client.write(teststring);
// handle connection timeout if too slow
mqo.ctimo = setTimeout(function() {
mqo.ctimo = null;
mqo.emit("disconnected");
mqo.disconnect();
}, C.CONNECT_TIMEOUT);
// Incoming data
var handler = mqo.packetHandler.bind(mqo);
client.on("data", handler);
// Socket closed
client.on("end", function() {
mqo._scktClosed();
});
});
} catch (e) {
this.client = null;
this.emit("error", e.message);
}
}
},
{
/** Called internally when the connection closes */ key: "_scktClosed",
value: function _scktClosed() {
if (this.connected) {
this.client = null;
this.connected = false;
if (this.pintr) clearInterval(this.pintr);
if (this.ctimo) clearTimeout(this.ctimo);
this.pintr = this.ctimo = undefined;
this.emit("disconnected");
this.emit("close");
}
}
},
{
/** Disconnect from server */ key: "disconnect",
value: function disconnect() {
if (!this.client) return;
try {
this.client.write(createBufferFromArray([
TYPE.DISCONNECT << 4,
0
]));
} catch (e) {
return this._scktClosed();
}
this.client.end();
this.client = null;
}
},
{
/** Create connection flags */ key: "createFlagsForConnection",
value: function createFlagsForConnection(clean) {
var flags = 0;
flags |= this.username ? 0x80 : 0;
flags |= this.username && this.password ? 0x40 : 0;
flags |= clean ? 0x02 : 0;
return flags;
}
},
{
/** CONNECT control packet
Clean Session and Userid/Password are currently only supported
connect flag. Wills are not
currently supported.
*/ key: "mqttConnect",
value: function mqttConnect(clean) {
var cmd = TYPE.CONNECT << 4;
var flags = this.createFlagsForConnection(clean);
var keep_alive = [
this.options.keep_alive >> 8,
this.options.keep_alive & 255
];
/* payload */ var payload = this.clientId;
if (this.username) {
payload = payload.concat(this.username);
if (this.password) {
payload = payload.concat(this.password);
}
}
return mqttPacket(cmd, mqttStr(this.options.protocol_name)/*protocol name*/ .concat([
this.options.protocol_level
])/*protocol level*/ .concat([
flags
]).concat(keep_alive), payload);
}
},
{
key: "packetHandler",
value: function packetHandler(data) {
if (!this.client) {
this.emit("error", "disconnected mid packet handling");
throw new Error("disconnected mid packet handling");
}
// if we had some data left over from last
// time, add it on
if (this.partData && this.partData.length > 0) {
data = createBufferFromArray(Array.prototype.slice.call(this.partData).concat(Array.prototype.slice.call(data)));
this.partData = [];
}
// Figure out packet length...
var dLen = mqttPacketLengthDec(data.slice(1, data.length));
var pLen = dLen.decLen + dLen.lenBy + 1;
// less than one packet?
if (data.length < pLen) {
this.partData = data;
return;
}
// Get the data for this packet
var pData = data.slice(1 + dLen.lenBy, pLen);
// Handle this MQTT packet
var cmd = data[0];
var type = cmd >> 4;
if (type === TYPE.PUBLISH) {
var qos = (cmd & 0x6) >> 1;
var topic_len = pData[0] << 8 | pData[1];
var msg_start = 2 + topic_len + (qos ? 2 : 0);
var parsedData = {
topic: pData.slice(2, 2 + topic_len).toString("utf8"),
message: pData.slice(msg_start, pData.length).toString("utf8"),
dup: (cmd & 0x8) >> 3,
qos: qos,
pid: qos ? pData.slice(2 + topic_len, 4 + topic_len) : 0,
retain: cmd & 0x1
};
if (parsedData.qos) {
var _d = (parsedData.qos == 1 ? TYPE.PUBACK : TYPE.PUBREC) << 4;
this.client.write([
_d,
2,
parsedData.pid
]);
}
this.emit("publish", parsedData);
this.emit("message", parsedData.topic, parsedData.message);
} else if (type === TYPE.PUBACK) {
this.emit("puback", data.toString().charCodeAt(2) << 8 | data.toString().charCodeAt(3));
} else if (type === TYPE.PUBREC) {
var pubrelArray = [
TYPE.PUBREL << 4 | 2,
2
];
var pidArray = Array.prototype.slice.call(getPid(pData));
var pubrecResponse = pubrelArray.concat(pidArray);
this.client.write(Buffer.from(pubrecResponse));
} else if (type === TYPE.PUBREL) {
var pubcompArray = [
TYPE.PUBCOMP << 4,
2
];
var pidArray = Array.prototype.slice.call(getPid(pData));
var pubrelResponse = pubcompArray.concat(pidArray);
this.client.write(pubrelResponse);
} else if (type === TYPE.PUBCOMP) {
this.emit("pubcomp", data.toString().charCodeAt(2) << 8 | data.toString().charCodeAt(3));
} else if (type === TYPE.SUBACK) {
if (pData.length > 0) {
if (pData[pData.length - 1] == 0x80) {
this.emit("subscribed_fail");
} else {
this.emit("subscribed");
}
}
} else if (type === TYPE.UNSUBACK) {
this.emit("unsubscribed");
} else if (type === TYPE.PINGREQ) {
this.client.write([
TYPE.PINGRESP << 4,
0
]);
} else if (type === TYPE.PINGRESP) {
this.emit("ping_reply");
} else if (type === TYPE.CONNACK) {
if (this.ctimo) clearTimeout(this.ctimo);
this.ctimo = undefined;
this.partData = [];
var returnCode = pData[1];
if (RETURN_CODES[returnCode] === "ACCEPTED") {
this.connected = true;
// start pinging
if (this.pintr) clearInterval(this.pintr);
this.pintr = setInterval(this.ping.bind(this), this.pingInterval * 1000);
// emit connected events
this.emit("connected");
this.emit("connect");
} else {
var mqttError = "Connection refused, ";
this.connected = false;
if (returnCode > 0 && returnCode < 6) {
mqttError += RETURN_CODES[returnCode];
} else {
mqttError += "unknown return code: " + returnCode + ".";
}
this.emit("error", mqttError);
}
// more than one packet? re-emit it so we handle it later
if (data.length > pLen) {
this.client.emit("data", data.slice(pLen, data.length));
}
} else {
this.emit("error", "MQTT unsupported packet type: " + type);
}
}
},
{
/** Unsubscribe to topic (filter) */ key: "unsubscribe",
value: function unsubscribe(topic) {
if (!this.client) return;
var cmd = TYPE.UNSUBSCRIBE << 4 | 2;
this.client.write(mqttPacket(cmd, this.mqttPid(), mqttStr(topic)));
}
},
{
/** Send ping request to server */ key: "ping",
value: function ping() {
if (!this.client) return;
try {
this.client.write(Buffer.from([
TYPE.PINGREQ << 4,
0
]));
} catch (e) {
this._scktClosed();
}
}
},
{
/** Publish message using specified topic.
opts = {
retain: bool // the server should retain this message and send it out again to new subscribers
dup : bool // indicate the message is a duplicate because original wasn't ACKed (QoS > 0 only)
}
*/ key: "publish",
value: function publish(topic, message, opts) {
if (!this.client) return;
opts = opts || {};
try {
var payloadarray = [];
var i = 0;
var messagearray = message.split("");
for(var j = 0; j < message.length; j++){
var _char = messagearray[j];
var numberrepres = _char.charCodeAt(0);
payloadarray[i] = numberrepres;
i = i + 1;
}
var publishMessage = createMqttPublishPacket(topic, payloadarray, opts.qos || C.DEF_QOS, (opts.retain ? 1 : 0) | (opts.dup ? 8 : 0), this.mqttPid());
this.client.write(publishMessage);
} catch (e) {
this._scktClosed();
}
}
},
{
/** Subscribe to topic (filter) */ key: "subscribe",
value: function subscribe(topics) {
var opts = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
if (!this.client) return;
var client = this.client;
var mqo = this;
opts = opts || {};
var subs = [];
if ("string" === typeof topics) {
topics = [
topics
];
}
if (Array.isArray(topics)) {
topics.forEach(function(topic) {
subs.push({
topic: topic,
qos: opts.qos || C.DEF_QOS
});
});
} else {
Object.keys(topics).forEach(function(k) {
subs.push({
topic: k,
qos: topics[k]
});
});
}
subs.forEach(function(sub) {
var subpacket = createMqttSubscribePacket(sub.topic, sub.qos, mqo.mqttPid());
client.write(subpacket);
});
}
}
]);
return FlicMQTT;
}();
function _define_property$2(obj, key, value) {
if (key in obj) {
Object.defineProperty(obj, key, {
value: value,
enumerable: true,
configurable: true,
writable: true
});
} else {
obj[key] = value;
}
return obj;
}
function _object_spread$2(target) {
for(var i = 1; i < arguments.length; i++){
var source = arguments[i] != null ? arguments[i] : {};
var ownKeys = Object.keys(source);
if (typeof Object.getOwnPropertySymbols === "function") {
ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
return Object.getOwnPropertyDescriptor(source, sym).enumerable;
}));
}
ownKeys.forEach(function(key) {
_define_property$2(target, key, source[key]);
});
}
return target;
}
var NODE_ID = "FlicHub";
var makeOptions$1 = function(opt) {
return _object_spread$2({
debug: false,
uniqueId: "0"
}, opt);
};
var getHADevice = function(options) {
return {
name: "FlicHub (".concat(options.uniqueId, ")"),
manufacturer: "Flic",
model: "".concat(NODE_ID).concat(options.uniqueId),
identifiers: [
"FlicHub"
],
configuration_url: "https://hubsdk.flic.io/",
sw_version: hubinfo.firmwareVersion,
serial_number: hubinfo.serialNumber
};
};
var getConstants$1 = function(ha, options) {
var nodeId = "".concat(NODE_ID).concat(options.uniqueId);
return {
NODE_ID: nodeId,
LIFELINE_SIGNAL: ha.genFlicPrefixObject(nodeId, "lifeline"),
MESSAGE: ha.genFlicPrefixObject(nodeId, "action-message"),
COMMAND_TOPIC: function(virtualId) {
return ha.genFlicPrefixObject(nodeId, "virt-command-".concat(virtualId));
}
};
};
var genVirtualDeviceObjectId = function(param) {
var virtualDeviceId = param.virtualDeviceId, dimmableType = param.dimmableType;
return "virt-".concat(dimmableType, "-").concat(virtualDeviceId).toLowerCase();
};
var VirtualDeviceType2HAComponent = {
Blind: "cover",
Light: "light",
Speaker: "media_player"
};
var virtualDeviceUpdateHandler = function(ha, logger, haDevice, nodeId, update, commandTopic, availability) {
var objectId = genVirtualDeviceObjectId(update.metaData);
var mqttPrefix = ha.genFlicPrefixObject(nodeId, objectId);
logger.info("Handling update for ".concat(update, " on ").concat(haDevice));
ha.registerEntity(update.metaData.virtualDeviceId, VirtualDeviceType2HAComponent[update.metaData.dimmableType], mqttPrefix.nodeId, mqttPrefix.objectId, haDevice, {
availability: availability,
command_topic: commandTopic
});
ha.publishState(mqttPrefix.nodeId, mqttPrefix.objectId, {
brightness: update.values.brightness * 255
});
};
var startFlicHubController = function(ha, mqtt) {
var _options = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
var options = makeOptions$1(_options);
var logger = makeLogger("flichub", options.debug);
var haDevice = getHADevice(options);
var constants = getConstants$1(ha, options);
var availability = [
{
payload_available: "ON",
payload_not_available: "unavailable",
topic: constants.LIFELINE_SIGNAL.mqttPrefix
}
];
logger.info("starting...");
logger.debug("setting up entities...");
ha.startLifeLine("FlicHub Connected", constants.NODE_ID, haDevice, constants.LIFELINE_SIGNAL.objectId);
ha.registerEntity("Action Message", "sensor", constants.NODE_ID, constants.MESSAGE.objectId, haDevice, {
icon: "mdi:message",
availability: availability
});
ha.publishState(constants.NODE_ID, constants.MESSAGE.objectId, "");
flichub.on("actionMessage", function(obj) {
ha.publishState(constants.NODE_ID, constants.MESSAGE.objectId, obj);
});
flichub.on("virtualDeviceUpdate", function(update) {
return virtualDeviceUpdateHandler(ha, logger, haDevice, constants.NODE_ID, update, constants.COMMAND_TOPIC(update.metaData.virtualDeviceId), availability);
});
};
function _array_like_to_array(arr, len) {
if (len == null || len > arr.length) len = arr.length;
for(var i = 0, arr2 = new Array(len); i < len; i++)arr2[i] = arr[i];
return arr2;
}
function _array_without_holes(arr) {
if (Array.isArray(arr)) return _array_like_to_array(arr);
}
function _define_property$1(obj, key, value) {
if (key in obj) {
Object.defineProperty(obj, key, {
value: value,
enumerable: true,
configurable: true,
writable: true
});
} else {
obj[key] = value;
}
return obj;
}
function _iterable_to_array(iter) {
if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
}
function _non_iterable_spread() {
throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
function _object_spread$1(target) {
for(var i = 1; i < arguments.length; i++){
var source = arguments[i] != null ? arguments[i] : {};
var ownKeys = Object.keys(source);
if (typeof Object.getOwnPropertySymbols === "function") {
ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
return Object.getOwnPropertyDescriptor(source, sym).enumerable;
}));
}
ownKeys.forEach(function(key) {
_define_property$1(target, key, source[key]);
});
}
return target;
}
function ownKeys$1(object, enumerableOnly) {
var keys = Object.keys(object);
if (Object.getOwnPropertySymbols) {
var symbols = Object.getOwnPropertySymbols(object);
keys.push.apply(keys, symbols);
}
return keys;
}
function _object_spread_props$1(target, source) {
source = source != null ? source : {};
if (Object.getOwnPropertyDescriptors) {
Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
} else {
ownKeys$1(Object(source)).forEach(function(key) {
Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
});
}
return target;
}
function _to_consumable_array(arr) {
return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
}
function _unsupported_iterable_to_array(o, minLen) {
if (!o) return;
if (typeof o === "string") return _array_like_to_array(o, minLen);
var n = Object.prototype.toString.call(o).slice(8, -1);
if (n === "Object" && o.constructor) n = o.constructor.name;
if (n === "Map" || n === "Set") return Array.from(n);
if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _array_like_to_array(o, minLen);
}
var makeOptions = function(opt) {
return _object_spread$1({
debug: false
}, opt);
};
var genButtonUniqueId = function(bdaddr) {
return bdaddr.replace(/:/g, "_");
};
var getConstants = function(ha, bdaddr) {
var uniqId = genButtonUniqueId(bdaddr);
var lifeline = ha.genFlicPrefixObject(uniqId, "lifeline");
var ready = ha.genFlicPrefixObject(uniqId, "ready");
var connected = ha.genFlicPrefixObject(uniqId, "connected");
var key_availability = [
{
payload_available: "ON",
payload_not_available: "unavailable",
topic: lifeline.mqttPrefix
}
];
var availability = {
availability: _to_consumable_array(key_availability).concat([
{
payload_available: "ON",
payload_not_available: "unavailable",
topic: ready.mqttPrefix
},
{
payload_available: "ON",
payload_not_available: "unavailable",
topic: connected.mqttPrefix
}
]),
availability_mode: "all"
};
return {
uniqId: uniqId,
LIFELINE_SIGNAL: _object_spread_props$1(_object_spread$1({}, lifeline), {
component: "binary_sensor",
additionalProps: {
entity_category: "diagnostic",
expire_after: 5,
device_class: "connectivity",
name: "Button Controller Connected",
payload_not_available: "OFF"
}
}),
signals: {
READY: _object_spread_props$1(_object_spread$1({}, ready), {
component: "binary_sensor",
additionalProps: {
entity_category: "diagnostic",
expire_after: 5,
device_class: "connectivity",
name: "Button Ready",
payload_not_available: "OFF",
availability: key_availability
}
}),
CONNECTED: _object_spread_props$1(_object_spread$1({}, connected), {
component: "binary_sensor",
additionalProps: {
entity_category: "diagnostic",
expire_after: 5,
device_class: "connectivity",
name: "Button Connected",
payload_not_available: "OFF",
availability: key_availability
}
})
},
states: {
ACTION: _object_spread_props$1(_object_spread$1({}, ha.genFlicPrefixObject(uniqId, "action")), {
component: "sensor",
additionalProps: {
icon: "mdi:gesture-tap-button",
name: "Click Action",
availability: availability
}
}),
STATE: _object_spread_props$1(_object_spread$1({}, ha.genFlicPrefixObject(uniqId, "state")), {
component: "sensor",
additionalProps: {
icon: "mdi:radiobox-indeterminate-variant",
availability: availability
}
}),
BATTERY: _object_spread_props$1(_object_spread$1({}, ha.genFlicPrefixObject(uniqId, "battery")), {
component: "sensor",
additionalProps: {
expire_after: 5,
unit_of_measurement: "%",
device_class: "battery",
availability: availability
}
}),
ACTIVE_DISCONNECT: _object_spread_props$1(_object_spread$1({}, ha.genFlicPrefixObject(uniqId, "activeDisconnect")), {
component: "binary_sensor",
additionalProps: {
entity_category: "config",
expire_after: 5,
name: "Explicitly disconnected button by user",
availability: availability
}
})
},
actions: {
SHORT_PRESS: _object_spread_props$1(_object_spread$1({}, ha.genFlicPrefixObject(uniqId, "button_short_press")), {
component: "device_automation",
additionalProps: {
type: "button_short_press",
subtype: "button_1",
automation_type: "trigger",
payload: "button_short_press"
}
}),
LONG_PRESS: _object_spread_props$1(_object_spread$1({}, ha.genFlicPrefixObject(uniqId, "button_long_press")), {
component: "device_automation",
additionalProps: {
type: "button_long_press",
subtype: "button_1",
automation_type: "trigger",
payload: "button_long_press"
}
}),
DOUBLE_PRESS: _object_spread_props$1(_object_spread$1({}, ha.genFlicPrefixObject(uniqId, "button_double_press")), {
component: "device_automation",
additionalProps: {
type: "button_double_press",
subtype: "button_1",
automation_type: "trigger",
payload: "button_double_press"
}
})
}
};
};
var getDeviceFromButton = function(button) {
return {
name: button.name,
identifiers: [
button.serialNumber,
button.uuid
],
manufacturer: "Flic",
model: "v".concat(button.flicVersion, "_").concat(button.color.trim().length > 0 ? button.color : "white"),
sw_version: String(button.firmwareVersion),
hw_version: String(button.flicVersion),
serial_number: String(button.serialNumber),
configuration_url: "https://hubsdk.flic.io/"
};
};
var registerEntities = function(ha, button, logger) {
var constants = getConstants(ha, button.bdaddr);
var haDevice = getDeviceFromButton(button);
logger.info("Registering", JSON.stringify({
bdaddr: button.bdaddr,
uniqId: constants.uniqId
}, null, 4));
ha.startLifeLine("Button Controller Connected", constants.uniqId, haDevice, constants.LIFELINE_SIGNAL.objectId);
registerHAObjects(constants.actions, ha, constants.uniqId, haDevice, logger);
registerHAObjects(constants.signals, ha, constants.uniqId, haDevice, logger);
registerHAObjects(constants.states, ha, constants.uniqId, haDevice, logger);
return constants;
};
var registerHAObjects = function(objs, ha, uniqId, haDevice, logger) {
Object.keys(objs).forEach(function(k) {
var o = objs[k];
logger.info("Registering", JSON.stringify({
entity: k,
objcetId: o.objectId,
uniqId: uniqId
}, null, 4));
ha.registerEntity("Button ".concat(o.objectId), o.component, uniqId, o.objectId, haDevice, o.additionalProps);
});
};
var deregisterButton = function(ha, bdaddr, logger) {
var constants = getConstants(ha, bdaddr);
var uniqId = constants.uniqId;
logger.info("Deregistering", JSON.stringify({
bdaddr: bdaddr,
uniqId: uniqId
}, null, 4));
deregisterHAObjects(constants.actions, ha, uniqId, logger);
deregisterHAObjects(constants.signals, ha, uniqId, logger);
deregisterHAObjects(constants.states, ha, uniqId, logger);
};
var deregisterHAObjects = function(objs, ha, uniqId, logger) {
Object.keys(objs).forEach(function(k) {
var o = objs[k];
logger.info("Deregistering", JSON.stringify({
entity: k,
objcetId: o.objectId,
uniqId: uniqId
}, null, 4));
ha.deregisterEntity(o.component, uniqId, o.objectId);
});
};
var createHandleBtnCreation = function(ha, logger) {
return function(eventName) {
return function(button) {
logger.info(eventName, "upserting", button.name, genButtonUniqueId(button.bdaddr));
var constants = registerEntities(ha, button, logger);
publishButtonMeta(ha, button, constants, logger);
return constants;
};
};
};
var publishButtonMeta = function(ha, button, constants, logger) {
logger.debug("Publishing Button Metadata ".concat(JSON.stringify(button)));
ha.publishStateFromObject(constants.states.BATTERY, button.batteryStatus);
ha.publishStateFromObject(constants.signals.CONNECTED, button.connected ? "ON" : "OFF");
ha.publishStateFromObject(constants.signals.READY, button.ready ? "ON" : "OFF");
ha.publishStateFromObject(constants.states.ACTIVE_DISCONNECT, button.activeDisconnect ? "ON" : "OFF");
return constants;
};
var publishButtonMetaByBdaddr = function(ha, bdaddr, logger) {
var button = buttonModule.getButton(bdaddr);
if (!button) {
logger.error("Cannot publish metadata for ".concat({
bdaddr: bdaddr
}));
return null;
}
var constants = getConstants(ha, bdaddr);
return publishButtonMeta(ha, button, constants, logger);
};
var publishButtonAction = function(ha, logger, constants, state) {
ha.publishStateFromObject(constants.states.ACTION, state);
logger.debug('Publishing click for uniqId="'.concat(constants.uniqId, '" state=').concat(state));
if (state === "click") {
ha.publishStateFromObject(constants.actions.SHORT_PRESS, constants.actions.SHORT_PRESS.objectId);
} else if (state === "double_click") {
ha.publishStateFromObject(constants.actions.DOUBLE_PRESS, constants.actions.DOUBLE_PRESS.objectId);
} else if (state === "hold") {
ha.publishStateFromObject(constants.actions.LONG_PRESS, constants.actions.LONG_PRESS.objectId);
}
};
var setListeners = function(ha, logger) {
var resetActiontInv = {};
var handleButtonCreation = createHandleBtnCreation(ha, logger);
buttonModule.on("buttonAdded", function(btn) {
return handleButtonCreation("buttonAdded")(btn.button);
});
buttonModule.on("buttonUpdated", function(btn) {
return handleButtonCreation("buttonUpdated")(btn.button);
});
buttonModule.on("buttonDeleted", function(param) {
var bdaddr = param.bdaddr;
deregisterButton(ha, bdaddr, logger);
if (resetActiontInv[bdaddr]) {
clearTimeout(resetActiontInv[bdaddr]);
resetActiontInv[bdaddr] = null;
}
});
buttonModule.on("buttonConnected", function(param) {
var bdaddr = param.bdaddr;
var btn = buttonModule.getButton(bdaddr);
if (btn) {
handleButtonCreation("buttonConnected")(btn);
}
});
buttonModule.on("buttonReady", function(param) {
var bdaddr = param.bdaddr;
var btn = buttonModule.getButton(bdaddr);
if (btn) {
var constants = handleButtonCreation("buttonReady")(btn);
ha.publishStateFromObject(constants.states.STATE, "released");
publishButtonAction(ha, logger, constants, "none");
}
});
buttonModule.on("buttonDisconnected", function(param) {
var bdaddr = param.bdaddr;
if (resetActiontInv[bdaddr]) {
clearTimeout(resetActiontInv[bdaddr]);
resetActiontInv[bdaddr] = null;
}
publishButtonMetaByBdaddr(ha, bdaddr, logger);
});
buttonModule.on("buttonDown", function(param) {
var bdaddr = param.bdaddr;
var constants = publishButtonMetaByBdaddr(ha, bdaddr, logger);
if (constants) {
ha.publishStateFromObject(constants.states.STATE, "pressed");
}
});
buttonModule.on("buttonUp", function(param) {
var bdaddr = param.bdaddr;
var constants = publishButtonMetaByBdaddr(ha, bdaddr, logger);
if (constants) {
ha.publishStateFromObject(constants.states.STATE, "released");
}
});
buttonModule.on("buttonSingleOrDoubleClickOrHold", function(obj) {
var constants = publishButtonMetaByBdaddr(ha, obj.bdaddr, logger);
if (constants) {
if (resetActiontInv[obj.bdaddr]) {
clearTimeout(resetActiontInv[obj.bdaddr]);
resetActiontInv[obj.bdaddr] = null;
}
publishButtonAction(ha, logger, constants, obj.isSingleClick ? "click" : obj.isDoubleClick ? "double_click" : "hold");
resetActiontInv[obj.bdaddr] = setTimeout(function() {
publishButtonAction(ha, logger, constants, "none");
}, 750);
}
});
};
var startButtinStateHandler = function(ha) {
var _options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
var options = makeOptions(_options);
var logger = makeLogger("btnc", options.debug);
logger.info("Starting Flic ButtonController with", JSON.stringify(options, null, 4));
logger.info("Setting listeners...");
setListeners(ha, logger);
logger.info("Registering all buttons...");
var handleCreation = createHandleBtnCreation(ha, logger)("kickStart");
buttonModule.getButtons().forEach(handleCreation);
setInterval(function() {
logger.debug("Updating button state!");
buttonModule.getButtons().forEach(function(btn) {
return publishButtonMetaByBdaddr(ha, btn.bdaddr, logger);
});
}, 3000);
logger.info("is up");
};
function _define_property(obj, key, value) {
if (key in obj) {
Object.defineProperty(obj, key, {
value: value,
enumerable: true,
configurable: true,
writable: true
});
} else {
obj[key] = value;
}
return obj;
}
function _object_spread(target) {
for(var i = 1; i < arguments.length; i++){
var source = arguments[i] != null ? arguments[i] : {};
var ownKeys = Object.keys(source);
if (typeof Object.getOwnPropertySymbols === "function") {
ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
return Object.getOwnPropertyDescriptor(source, sym).enumerable;
}));
}
ownKeys.forEach(function(key) {
_define_property(target, key, source[key]);
});
}
return target;
}
function ownKeys(object, enumerableOnly) {
var keys = Object.keys(object);
if (Object.getOwnPropertySymbols) {
var symbols = Object.getOwnPropertySymbols(object);
keys.push.apply(keys, symbols);
}
return keys;
}
function _object_spread_props(target, source) {
source = source != null ? source : {};
if (Object.getOwnPropertyDescriptors) {
Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
} else {
ownKeys(Object(source)).forEach(function(key) {
Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
});
}
return target;
}
var start = function(options) {
var mqttServer = new FlicMQTT(options.mqtt.host, _object_spread_props(_object_spread({}, options.mqtt), {
keep_alive: true
}));
var _options_debug;
var logger = makeLogger("root", (_options_debug = options.debug) !== null && _options_debug !== void 0 ? _options_debug : false);
var _options_ha;
options.ha = (_options_ha = options.ha) !== null && _options_ha !== void 0 ? _options_ha : {};
var _options_flicBtns;
options.flicBtns = (_options_flicBtns = options.flicBtns) !== null && _options_flicBtns !== void 0 ? _options_flicBtns : {};
var _options_flicIR;
options.flicIR = (_options_flicIR = options.flicIR) !== null && _options_flicIR !== void 0 ? _options_flicIR : {};
var _options_flicHub;
options.flicHub = (_options_flicHub = options.flicHub) !== null && _options_flicHub !== void 0 ? _options_flicHub : {};
var _options_ha_debug, _ref;
options.ha.debug = (_ref = (_options_ha_debug = options.ha.debug) !== null && _options_ha_debug !== void 0 ? _options_ha_debug : options.debug) !== null && _ref !== void 0 ? _ref : false;
var _options_flicBtns_debug, _ref1;
options.flicBtns.debug = (_ref1 = (_options_flicBtns_debug = options.flicBtns.debug) !== null && _options_flicBtns_debug !== void 0 ? _options_flicBtns_debug : options.debug) !== null && _ref1 !== void 0 ? _ref1 : false;
var _options_flicIR_debug, _ref2;
options.flicIR.debug = (_ref2 = (_options_flicIR_debug = options.flicIR.debug) !== null && _options_flicIR_debug !== void 0 ? _options_flicIR_debug : options.debug) !== null && _ref2 !== void 0 ? _ref2 : false;
var _options_flicHub_debug, _ref3;
options.flicHub.debug = (_ref3 = (_options_flicHub_debug = options.flicHub.debug) !== null && _options_flicHub_debug !== void 0 ? _options_flicHub_debug : options.debug) !== null && _ref3 !== void 0 ? _ref3 : false;
var ha = makeHAmqtt(mqttServer, options.ha);
mqttServer.on("connected", function() {
var _options_flicBtns, _options_flicIR, _options_flicHub;
logger.info("connected to mqtt");
if (!((_options_flicBtns = options.flicBtns) === null || _options_flicBtns === void 0 ? void 0 : _options_flicBtns.disabled)) {
startButtinStateHandler(ha, options.flicBtns);
}
if (!((_options_flicIR = options.flicIR) === null || _options_flicIR === void 0 ? void 0 : _options_flicIR.disabled)) {
startIRController(ha, mqttServer, options.flicIR);
}
if (!((_options_flicHub = options.flicHub) === null || _options_flicHub === void 0 ? void 0 : _options_flicHub.disabled)) {
startFlicHubController(ha, mqttServer, options.flicHub);
}
logger.info("all services up!");
});
mqttServer.on("error", function(err) {
logger.info("'Error' event", JSON.stringify(err));
setTimeout(function() {
throw new Error("Crashed");
}, 1000);
});
mqttServer.on("disconnected", function() {
logger.info("Lost access - disconnected");
setTimeout(function() {
throw new Error("disconnected");
}, 1000);
});
mqttServer.on("close", function() {
logger.info("Lost access - close");
setTimeout(function() {
throw new Error("closed");
}, 1000);
});
mqttServer.connect();
};
exports.start = start;