@robotical/webapp-types 1.0.0

package/dist-types/src/wrapper-app/WrapperAppManager.js

@@ -0,0 +1,176 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { WrapperSentMessage } from "../types/communication-between-apps/wrapper-communication";
+import Logger from "../services/logger/Logger";
+import { RaftConnEvent } from "@robdobsn/raftjs";
+import ConnectorFactory from "./connectors/ConnectorFactory";
+var SHOW_LOGS = true;
+var TAG = "WrapperAppManager";
+var WrapperAppManager = /** @class */ (function () {
+    function WrapperAppManager() {
+        // Connectors 
+        this.connectors = {};
+        // Observers
+        this._observers = {};
+    }
+    /**
+    * Connect to a RAFT
+    *
+    * @param {string} method - can be "WebBLE" or "WebSocket"
+    * @param {string | object} locator - either a string (WebSocket URL) or an object (WebBLE)
+    * @returns Promise<ConnectionAttemptResults>
+    *
+    */
+    WrapperAppManager.prototype.connect = function (method) {
+        return __awaiter(this, void 0, void 0, function () {
+            var connector, connectionResults;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, ConnectorFactory.connectToRaftHelper(method)];
+                    case 1:
+                        connector = _a.sent();
+                        if (!connector) {
+                            Logger.warn(SHOW_LOGS, TAG, "Failed to connect to RAFT with method: ".concat(method));
+                            return [2 /*return*/, { success: false, reason: "failed" }];
+                        }
+                        return [4 /*yield*/, connector.connect()];
+                    case 2:
+                        connectionResults = _a.sent();
+                        if (connectionResults.success) {
+                            this.connectors[connector.id] = connector;
+                            connectionResults.data = { raftId: connector.id, raftType: connector.type };
+                        }
+                        else {
+                            Logger.warn(SHOW_LOGS, TAG, "Failed to connect to RAFT with id: ".concat(connector.id, " and type: ").concat(connector.type));
+                        }
+                        Logger.info(SHOW_LOGS, TAG, "Connected to RAFT with id: ".concat(connector.id, " and type: ").concat(connector.type));
+                        return [2 /*return*/, connectionResults];
+                }
+            });
+        });
+    };
+    /**
+     * Re-triggers the connect event which was missed due to the connection logic
+     */
+    WrapperAppManager.prototype.getMissedConnEvent = function (raftId) {
+        if (this.connectors[raftId]) {
+            this.connectors[raftId].eventHandler("conn", RaftConnEvent.CONN_CONNECTED, "connect", {});
+            this.connectors[raftId].publish("conn", RaftConnEvent.CONN_CONNECTED, "connect", {});
+        }
+    };
+    /**
+     * Get the RAFT Name
+     */
+    WrapperAppManager.prototype.getRaftName = function (raftId) {
+        if (this.connectors[raftId]) {
+            return this.connectors[raftId].getRaftName();
+        }
+        return "";
+    };
+    /**
+     * Verify RAFT
+     */
+    WrapperAppManager.prototype.verifyRaft = function (ledLcdColours, raftId) {
+        if (!this.connectors[raftId]) {
+            Logger.warn(SHOW_LOGS, TAG, "verifyRaft: No connector found for raftId: ".concat(raftId));
+            return false;
+        }
+        return this.connectors[raftId].verifyRaft(ledLcdColours);
+    };
+    /**
+     * Stop verifying RAFT
+     */
+    WrapperAppManager.prototype.stopVerifyingRaft = function (isCorrectRIC, raftId) {
+        if (!isCorrectRIC) {
+            this._removeRICConnector(raftId, 11000);
+        }
+        return this.connectors[raftId].stopVerifyingRaft(isCorrectRIC);
+    };
+    /**
+     * Disconnect from a RAFT
+     */
+    WrapperAppManager.prototype.disconnect = function (raftId) {
+        this._removeRICConnector(raftId, 11000);
+        return this.connectors[raftId].disconnect();
+    };
+    /**
+     * Audio streaming
+     */
+    WrapperAppManager.prototype.streamAudio = function (raftId, streamContents, clearExisting, duration) {
+        return this.connectors[raftId].streamAudio(streamContents, clearExisting, duration);
+    };
+    /**
+     * Publish an event to all observers
+     * Set in RICConnector as an event listener callback
+     */
+    WrapperAppManager.prototype.publish = function (eventType, eventEnum, eventName, eventData) {
+        window.WebAppCommunicator.sendMessageNoWait(WrapperSentMessage.RAFT_PUBLISHED_EVENT, { eventType: eventType, eventEnum: eventEnum, eventName: eventName, eventData: eventData });
+        if (this._observers.hasOwnProperty(eventType)) {
+            for (var _i = 0, _a = this._observers[eventType]; _i < _a.length; _i++) {
+                var observer = _a[_i];
+                observer.notify(eventType, eventEnum, eventName, eventData);
+            }
+        }
+    };
+    /**
+     * Send a REST message to the RAFT
+     */
+    WrapperAppManager.prototype.sendRestMessage = function (msg, params, raftId) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.connectors[raftId].sendRestMessage(msg, params)];
+            });
+        });
+    };
+    /**
+     * Removes marty after a certain time
+     * Removes from the martys list after x seconds so that we can still get the last event
+     */
+    WrapperAppManager.prototype._removeRICConnector = function (connectorId, timeout) {
+        var _this = this;
+        var martyRemovalTimeout = setTimeout(function () {
+            delete _this.connectors[connectorId];
+            clearTimeout(martyRemovalTimeout);
+        }, timeout);
+    };
+    return WrapperAppManager;
+}());
+export { WrapperAppManager };
+var wrapperAppManager = new WrapperAppManager();
+// @ts-ignore : just for debugging
+window.wrapperAppManager = wrapperAppManager;
+export default wrapperAppManager;

package/dist-types/src/wrapper-app/communicators/WebAppCommunicator.d.ts

@@ -0,0 +1,24 @@
+import { WEB_APP_MESSAGE_BASE, WrapperSentMessage } from "../../types/communication-between-apps/wrapper-communication";
+/**
+ * This file is responsible for the communication between the web app and the Wrapper Web App
+ */
+declare class WebAppCommunicator {
+    private messagePromises;
+    constructor();
+    receiveMessage(receivedMessageStringified: string): Promise<void>;
+    /**
+     * It sends a message to the phone app
+     * The client can await the response to that message
+     */
+    sendMessageAndWait<R>(message: WrapperSentMessage, data?: any): Promise<R>;
+    /**
+     * It sends a message to the phone app
+     * The client cannot await the response to that message
+     */
+    sendMessageNoWait(message: WrapperSentMessage, data?: any): void;
+    /**
+     * Called by the react-native code to respond to sendMessage
+     */
+    onMessageResponse(response: WEB_APP_MESSAGE_BASE): void;
+}
+export default WebAppCommunicator;

package/dist-types/src/wrapper-app/communicators/WebAppCommunicator.js

@@ -0,0 +1,243 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import SelfdestructiveMessagePromise from "../../application/communicators/SelfdestructiveMessagePromise";
+import Logger from "../../services/logger/Logger";
+import { AppSentMessage } from "../../types/communication-between-apps/wrapper-communication";
+import randomHashGenerator from "../../utils/helpers/randomHashGenerator";
+import wrapperAppManager from "../WrapperAppManager";
+var SHOW_LOGS = true;
+var TAG = "WebAppCommunicator";
+/**
+ * This file is responsible for the communication between the web app and the Wrapper Web App
+ */
+var WebAppCommunicator = /** @class */ (function () {
+    function WebAppCommunicator() {
+        this.messagePromises = {};
+    }
+    WebAppCommunicator.prototype.receiveMessage = function (receivedMessageStringified) {
+        return __awaiter(this, void 0, void 0, function () {
+            var receivedMessage;
+            return __generator(this, function (_a) {
+                Logger.info(SHOW_LOGS, TAG, "Received message: " + receivedMessageStringified);
+                receivedMessage = JSON.parse(receivedMessageStringified);
+                receivedMessageHandler(receivedMessage.message, receivedMessage.data, receivedMessage.messagePromiseId);
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+     * It sends a message to the phone app
+     * The client can await the response to that message
+     */
+    WebAppCommunicator.prototype.sendMessageAndWait = function (message, data) {
+        var _this = this;
+        Logger.info(SHOW_LOGS, TAG, "Sending message with waiting: " + message);
+        var messagePromiseId = randomHashGenerator();
+        var promise = new Promise(function (resolve, reject) {
+            // this.messagePromises[messagePromiseId] = { resolve: (value: R | PromiseLike<R>) => resolve(value), reject };
+            _this.messagePromises[messagePromiseId] = new SelfdestructiveMessagePromise(resolve, reject, messagePromiseId, _this.messagePromises);
+        });
+        var messageObject = {
+            message: message,
+            data: data,
+            messagePromiseId: messagePromiseId
+        };
+        window.wrapperCommunicator.receiveMessage(messageObject);
+        return promise;
+    };
+    /**
+     * It sends a message to the phone app
+     * The client cannot await the response to that message
+     */
+    WebAppCommunicator.prototype.sendMessageNoWait = function (message, data) {
+        // Logger.info(SHOW_LOGS, TAG, "Sending message without waiting: " + message);
+        var messagePromiseId = randomHashGenerator();
+        var messageObject = {
+            message: message,
+            data: data,
+            messagePromiseId: messagePromiseId
+        };
+        window.wrapperCommunicator.receiveMessage(messageObject);
+    };
+    /**
+     * Called by the react-native code to respond to sendMessage
+     */
+    WebAppCommunicator.prototype.onMessageResponse = function (response) {
+        var _a, _b;
+        Logger.info(SHOW_LOGS, TAG, "Received message reply: " + JSON.stringify(response));
+        if (this.messagePromises[response.messagePromiseId]) {
+            if (response.success) {
+                (_a = this.messagePromises[response.messagePromiseId]) === null || _a === void 0 ? void 0 : _a.resolve(response.results);
+            }
+            else {
+                (_b = this.messagePromises[response.messagePromiseId]) === null || _b === void 0 ? void 0 : _b.reject(response.error);
+            }
+        }
+        else {
+            Logger.warn(SHOW_LOGS, TAG, "Unhandled message reply with id: ".concat(response.messagePromiseId));
+        }
+    };
+    return WebAppCommunicator;
+}());
+export default WebAppCommunicator;
+var receivedMessageHandler = function (receivedMessage, data, messagePromiseId) { return __awaiter(void 0, void 0, void 0, function () {
+    var _a, connectionResults, error_1, ricName, error_2, verifyResults, error_3, stopVerifyResults, error_4, disconnectResults, error_5, restResults, error_6, missedConnEventResults, streamAudioResults;
+    return __generator(this, function (_b) {
+        switch (_b.label) {
+            case 0:
+                _a = receivedMessage;
+                switch (_a) {
+                    case AppSentMessage.RAFT_IS_CONNECTED: return [3 /*break*/, 1];
+                    case AppSentMessage.RAFT_CONNECT: return [3 /*break*/, 2];
+                    case AppSentMessage.RAFT_GET_NAME: return [3 /*break*/, 6];
+                    case AppSentMessage.RAFT_VERIFY: return [3 /*break*/, 10];
+                    case AppSentMessage.RAFT_STOP_VERIFY: return [3 /*break*/, 14];
+                    case AppSentMessage.RAFT_DISCONNECT: return [3 /*break*/, 18];
+                    case AppSentMessage.RAFT_SEND_REST: return [3 /*break*/, 22];
+                    case AppSentMessage.GET_MISSED_CONN_EVENT: return [3 /*break*/, 26];
+                    case AppSentMessage.RAFT_STREAM_AUDIO: return [3 /*break*/, 27];
+                }
+                return [3 /*break*/, 28];
+            case 1:
+                try {
+                    console.log("3");
+                    // const connectionResults = await wrapperAppManager.isConnected();
+                    console.log("12");
+                    // console.log("raft is connected results", connectionResults);
+                    window.wrapperCommunicator.onMessageResponse({ success: true, error: "", results: { log: "13" }, messagePromiseId: messagePromiseId });
+                }
+                catch (error) {
+                    window.wrapperCommunicator.onMessageResponse({ success: false, error: error.message, messagePromiseId: messagePromiseId });
+                }
+                return [3 /*break*/, 29];
+            case 2:
+                _b.trys.push([2, 4, , 5]);
+                return [4 /*yield*/, wrapperAppManager.connect(data.method)];
+            case 3:
+                connectionResults = _b.sent();
+                window.wrapperCommunicator.onMessageResponse({ success: true, error: "", results: connectionResults, messagePromiseId: messagePromiseId });
+                return [3 /*break*/, 5];
+            case 4:
+                error_1 = _b.sent();
+                window.wrapperCommunicator.onMessageResponse({ success: false, error: error_1.message, messagePromiseId: messagePromiseId });
+                return [3 /*break*/, 5];
+            case 5: return [3 /*break*/, 29];
+            case 6:
+                _b.trys.push([6, 8, , 9]);
+                return [4 /*yield*/, wrapperAppManager.getRaftName(data.raftId)];
+            case 7:
+                ricName = _b.sent();
+                window.wrapperCommunicator.onMessageResponse({ success: true, error: "", results: ricName, messagePromiseId: messagePromiseId });
+                return [3 /*break*/, 9];
+            case 8:
+                error_2 = _b.sent();
+                window.wrapperCommunicator.onMessageResponse({ success: false, error: error_2.message, messagePromiseId: messagePromiseId });
+                return [3 /*break*/, 9];
+            case 9: return [3 /*break*/, 29];
+            case 10:
+                _b.trys.push([10, 12, , 13]);
+                return [4 /*yield*/, wrapperAppManager.verifyRaft(data.ledLcdColours, data.raftId)];
+            case 11:
+                verifyResults = _b.sent();
+                window.wrapperCommunicator.onMessageResponse({ success: true, error: "", results: verifyResults, messagePromiseId: messagePromiseId });
+                return [3 /*break*/, 13];
+            case 12:
+                error_3 = _b.sent();
+                window.wrapperCommunicator.onMessageResponse({ success: false, error: error_3.message, messagePromiseId: messagePromiseId });
+                return [3 /*break*/, 13];
+            case 13: return [3 /*break*/, 29];
+            case 14:
+                _b.trys.push([14, 16, , 17]);
+                return [4 /*yield*/, wrapperAppManager.stopVerifyingRaft(data.isCorrectRIC, data.raftId)];
+            case 15:
+                stopVerifyResults = _b.sent();
+                window.wrapperCommunicator.onMessageResponse({ success: true, error: "", results: stopVerifyResults, messagePromiseId: messagePromiseId });
+                return [3 /*break*/, 17];
+            case 16:
+                error_4 = _b.sent();
+                window.wrapperCommunicator.onMessageResponse({ success: false, error: error_4.message, messagePromiseId: messagePromiseId });
+                return [3 /*break*/, 17];
+            case 17: return [3 /*break*/, 29];
+            case 18:
+                _b.trys.push([18, 20, , 21]);
+                return [4 /*yield*/, wrapperAppManager.disconnect(data.raftId)];
+            case 19:
+                disconnectResults = _b.sent();
+                window.wrapperCommunicator.onMessageResponse({ success: true, error: "", results: disconnectResults, messagePromiseId: messagePromiseId });
+                return [3 /*break*/, 21];
+            case 20:
+                error_5 = _b.sent();
+                window.wrapperCommunicator.onMessageResponse({ success: false, error: error_5.message, messagePromiseId: messagePromiseId });
+                return [3 /*break*/, 21];
+            case 21: return [3 /*break*/, 29];
+            case 22:
+                _b.trys.push([22, 24, , 25]);
+                return [4 /*yield*/, wrapperAppManager.sendRestMessage(data.msg, data.params, data.raftId)];
+            case 23:
+                restResults = _b.sent();
+                window.wrapperCommunicator.onMessageResponse({ success: true, error: "", results: restResults, messagePromiseId: messagePromiseId });
+                return [3 /*break*/, 25];
+            case 24:
+                error_6 = _b.sent();
+                window.wrapperCommunicator.onMessageResponse({ success: false, error: error_6.message, messagePromiseId: messagePromiseId });
+                return [3 /*break*/, 25];
+            case 25: return [3 /*break*/, 29];
+            case 26:
+                try {
+                    missedConnEventResults = wrapperAppManager.getMissedConnEvent(data.raftId);
+                    window.wrapperCommunicator.onMessageResponse({ success: true, error: "", results: missedConnEventResults, messagePromiseId: messagePromiseId });
+                }
+                catch (error) {
+                    window.wrapperCommunicator.onMessageResponse({ success: false, error: error.message, messagePromiseId: messagePromiseId });
+                }
+                return [3 /*break*/, 29];
+            case 27:
+                try {
+                    streamAudioResults = wrapperAppManager.streamAudio(data.raftId, data.streamContents, data.clearExisting, data.duration);
+                    window.wrapperCommunicator.onMessageResponse({ success: true, error: "", results: streamAudioResults, messagePromiseId: messagePromiseId });
+                }
+                catch (error) {
+                    window.wrapperCommunicator.onMessageResponse({ success: false, error: error.message, messagePromiseId: messagePromiseId });
+                }
+                return [3 /*break*/, 29];
+            case 28:
+                Logger.warn(SHOW_LOGS, TAG, "Unhandled message: ".concat(receivedMessage));
+                _b.label = 29;
+            case 29: return [2 /*return*/];
+        }
+    });
+}); };

package/dist-types/src/wrapper-app/connectors/CogConnector/CogConnector.d.ts

@@ -0,0 +1,35 @@
+import { RaftInfoEvents } from "../../../types/events/raft-info";
+import { ConnectionAttemptResults, RaftTypeE } from "../../../types/raft";
+import Connector from "../Connector";
+import ConnectorInterface from "../ConnectorInterface";
+import { RaftConnEvent, RaftPublishEvent, RaftUpdateEvent } from "@robdobsn/raftjs";
+import { ConnManager } from "@robotical/roboticaljs";
+declare class CogConnector extends Connector implements ConnectorInterface {
+    type: RaftTypeE;
+    constructor(raftId: string, connManager: ConnManager);
+    /**
+     * Connect to a RAFT
+     */
+    connect(): Promise<ConnectionAttemptResults>;
+    /**
+     * Disconnect from Cog
+     */
+    disconnect(): Promise<boolean>;
+    /**
+     * Event handler
+     */
+    eventHandler(eventType: string, eventEnum: RaftConnEvent | RaftUpdateEvent | RaftPublishEvent | RaftInfoEvents, eventName: string, data: any): Promise<void>;
+    /**
+     * Connection Event Handler
+     */
+    connectionEventHandler(eventEnum: RaftConnEvent, eventName: string, data: any): Promise<void>;
+    /**
+     * Update Event Handler
+     */
+    updateEventHandler(eventEnum: RaftUpdateEvent, eventName: string, data: any): Promise<void>;
+    /**
+     * Pub Event Handler
+     */
+    pubEventHandler(eventEnum: RaftPublishEvent, eventName: string, data: any): Promise<void>;
+}
+export default CogConnector;

package/dist-types/src/wrapper-app/connectors/CogConnector/CogConnector.js

@@ -0,0 +1,177 @@
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import Logger from "../../../services/logger/Logger";
+import { RaftTypeE } from "../../../types/raft";
+import Connector from "../Connector";
+import { RaftConnEvent, RaftUpdateEvent } from "@robdobsn/raftjs";
+var SHOW_LOGS = true;
+var TAG = "CogConnector";
+var CogConnector = /** @class */ (function (_super) {
+    __extends(CogConnector, _super);
+    function CogConnector(raftId, connManager) {
+        var _this = _super.call(this, raftId, connManager) || this;
+        _this.type = RaftTypeE.COG;
+        return _this;
+    }
+    /**
+     * Connect to a RAFT
+     */
+    CogConnector.prototype.connect = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var sysInfoOk;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.connManager.getConnector().getRaftSystemUtils().getSystemInfo()];
+                    case 1:
+                        sysInfoOk = _a.sent();
+                        if (!sysInfoOk) {
+                            // this.emit(RAFT_REJECTED)
+                            return [2 /*return*/, { success: false, reason: 'no_sys_info' }];
+                        }
+                        return [2 /*return*/, { success: true, reason: 'success' }];
+                }
+            });
+        });
+    };
+    /**
+     * Disconnect from Cog
+     */
+    CogConnector.prototype.disconnect = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, _super.prototype.disconnect.call(this)];
+                    case 1: 
+                    // this.sendRestMessage('blerestart');
+                    return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Event handler
+     */
+    CogConnector.prototype.eventHandler = function (eventType, eventEnum, eventName, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                _super.prototype.eventHandler.call(this, eventType, eventEnum, eventName, data);
+                switch (eventType) {
+                    case "conn":
+                        this.connectionEventHandler(eventEnum, eventName, data);
+                        break;
+                    case "update":
+                        this.updateEventHandler(eventEnum, eventName, data);
+                        break;
+                    case "pub":
+                        this.pubEventHandler(eventEnum, eventName, data);
+                        break;
+                    default:
+                        break;
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+     * Connection Event Handler
+     */
+    CogConnector.prototype.connectionEventHandler = function (eventEnum, eventName, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                Logger.info(SHOW_LOGS, TAG, "Event: ".concat(eventEnum, " data: ").concat(data));
+                switch (eventEnum) {
+                    case RaftConnEvent.CONN_CONNECTED:
+                        break;
+                    case RaftConnEvent.CONN_VERIFIED_CORRECT:
+                        break;
+                    default:
+                        break;
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+     * Update Event Handler
+     */
+    CogConnector.prototype.updateEventHandler = function (eventEnum, eventName, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                Logger.info(SHOW_LOGS, TAG, "Event: ".concat(eventEnum, " data: ").concat(data));
+                switch (eventEnum) {
+                    case RaftUpdateEvent.UPDATE_APP_UPDATE_REQUIRED:
+                        // do something
+                        break;
+                    default:
+                        break;
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+     * Pub Event Handler
+     */
+    CogConnector.prototype.pubEventHandler = function (eventEnum, eventName, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (eventEnum) {
+                    default:
+                        break;
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    return CogConnector;
+}(Connector));
+export default CogConnector;