@robotical/webapp-types 0.6.58

package/dist-types/src/application/RAFTs/Marty/Marty.js

@@ -0,0 +1,187 @@
+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 { RaftTypeE } from "../../../types/raft";
+import RAFT from "../RAFT";
+import { RaftPublishEvent } from "@robotical/raftjs";
+var Marty = /** @class */ (function (_super) {
+    __extends(Marty, _super);
+    function Marty(id) {
+        var _this = _super.call(this, id) || this;
+        _this.id = id;
+        _this.type = RaftTypeE.MARTY;
+        // RAFT State Info
+        _this.raftStateInfo = null;
+        // Marty System info
+        _this.systemInfo = null;
+        // Colours to use for LED patterns
+        _this._ledLcdColours = [
+            { led: "#202000", lcd: "#FFFF00" },
+            { led: "#880000", lcd: "#FF0000" },
+            { led: "#000040", lcd: "#0080FF" },
+        ];
+        // // Joint names
+        // private _jointNames = {
+        //     LeftHip: "LeftHip",
+        //     LeftTwist: "LeftTwist",
+        //     LeftKnee: "LeftKnee",
+        //     RightHip: "RightHip",
+        //     RightTwist: "RightTwist",
+        //     RightKnee: "RightKnee",
+        //     LeftArm: "LeftArm",
+        //     RightArm: "RightArm",
+        //     Eyes: "Eyes",
+        // };
+        _this.rssiValues = []; // Array to store recent RSSI values
+        _this.MAX_RSSI_VALUES_N = 8; // Number of values to consider for averaging
+        return _this;
+    }
+    Object.defineProperty(Marty.prototype, "ledLcdColours", {
+        get: function () {
+            return this._ledLcdColours;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+    * Gets the RSSI of the RAFT
+    */
+    Marty.prototype.getRSSI = function () {
+        var _a;
+        var newRssi = ((_a = this.raftStateInfo) === null || _a === void 0 ? void 0 : _a.robotStatus.robotStatus.bleRSSI) || -200;
+        if (this.rssiValues.length >= this.MAX_RSSI_VALUES_N) {
+            this.rssiValues.shift();
+        }
+        this.rssiValues.push(newRssi);
+        var rssiAverage = this.rssiValues.reduce(function (sum, val) { return sum + val; }, 0) / this.rssiValues.length;
+        return rssiAverage;
+    };
+    /**
+     * Gets the battery strength of the RAFT
+     */
+    Marty.prototype.getBatteryStrength = function () {
+        var _a;
+        return ((_a = this.raftStateInfo) === null || _a === void 0 ? void 0 : _a.power.powerStatus.battRemainCapacityPercent) || 0;
+    };
+    /**
+     * Highlights Marty by flashing the LED and playing a tune
+     */
+    Marty.prototype.highlight = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.sendRestMessage('led/LEDeye/color/#ff8585')];
+                    case 1:
+                        _a.sent();
+                        return [4 /*yield*/, this.sendRestMessage('filerun/arcade-beep.mp3')];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, new Promise(function (resolve) { return setTimeout(resolve, 100); })];
+                    case 3:
+                        _a.sent();
+                        return [4 /*yield*/, this.sendRestMessage('led/LEDeye/color/#000000')];
+                    case 4:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+    * This methods handles RAFT events coming from the RICConnector of the wrapper
+    */
+    Marty.prototype.handleRaftEvent = function (eventType, eventEnum, eventName, eventData) {
+        _super.prototype.handleRaftEvent.call(this, eventType, eventEnum, eventName, eventData);
+        switch (eventType) {
+            case "pub":
+                this.pubEventHandler(eventEnum, eventName, eventData);
+                break;
+            case "raftinfo":
+                this.raftInfoEventHandler(eventEnum, eventName, eventData);
+                break;
+            default:
+                break;
+        }
+    };
+    /**
+     * Pub Event Handler
+     */
+    Marty.prototype.pubEventHandler = function (eventEnum, eventName, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (eventEnum) {
+                    case RaftPublishEvent.PUBLISH_EVENT_DATA:
+                        break;
+                    default:
+                        break;
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+     * Raft Info Event Handler
+     */
+    Marty.prototype.raftInfoEventHandler = 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 Marty;
+}(RAFT));
+export { Marty };
+export default Marty;

package/dist-types/src/application/RAFTs/RAFT.d.ts

@@ -0,0 +1,114 @@
+import { ConnectionAttemptResults, RaftConnectionMethod, RaftTypeE } from "../../types/raft";
+import { RaftInfoEvents } from "../../types/events/raft-info";
+import { FOUND_RAFT_ON_DISCOVERY_RESPONSE } from "../../types/phone-app-communicator";
+import RICInterface from "./RAFTInterface";
+import { RaftObserver } from "./RaftObserver";
+import { RaftConnEvent, RaftUpdateEvent, RaftPublishEvent, RaftOKFail, RaftSystemInfo } from "@robotical/raftjs";
+import { RICLedLcdColours, RICStateInfo } from "@robotical/roboticaljs";
+import { SimplifiedCogStateInfo } from "@robotical/roboticaljs/dist/SystemTypeCog/CogTypes";
+export default class RAFT implements RICInterface {
+    id: string;
+    type: RaftTypeE;
+    _ledLcdColours: RICLedLcdColours;
+    protected _observers: {
+        [key: string]: Array<RaftObserver>;
+    };
+    isSerialNoRegisteredInWarranty: boolean | null;
+    systemInfo: RaftSystemInfo | null;
+    raftStateInfo: RICStateInfo | SimplifiedCogStateInfo | null;
+    /**
+     * Method to get ledLcdColours, to be implemented in child classes.
+     */
+    get ledLcdColours(): RICLedLcdColours;
+    constructor(id: string);
+    /**
+     * Check if RAFT is connected
+     * Sends a message to the Wrapper RICConnector and waits for a response
+     */
+    getIsConnectedFresh(): Promise<boolean>;
+    /**
+    * Connect to a RAFT
+    * We first connect, then we discover the raft type, and then we create the appopriate raft instance
+    */
+    static connect(method: RaftConnectionMethod, uuids: string[]): Promise<ConnectionAttemptResults>;
+    /**
+     * Disconnect from a RAFT
+     */
+    disconnect(): Promise<boolean>;
+    /**
+     * Get RAFT name
+     */
+    getRaftName(): Promise<string>;
+    /**
+    * Verify correct RAFT is selected for phone app
+    */
+    verifyRaftPhoneApp(discoveredDevice: FOUND_RAFT_ON_DISCOVERY_RESPONSE['foundRIC']): Promise<boolean>;
+    /**
+    * Verify correct RAFT is selected
+    */
+    verifyRaft(): Promise<boolean>;
+    /**
+     * Stops the verification process
+     */
+    stopVerifyingRaft(isCorrectRIC: boolean): Promise<boolean>;
+    /**
+     * Receiveds events from the RICConnector
+     */
+    receivedRICEvent(eventType: string, eventEnum: RaftConnEvent | RaftUpdateEvent | RaftPublishEvent | RaftInfoEvents, eventName: string, eventData: any): void;
+    /**
+     * Send a REST message to the RAFT
+     */
+    sendRestMessage(msg: string, params?: object): Promise<RaftOKFail>;
+    /**
+     * Highlights the raft
+     */
+    highlight(): Promise<void>;
+    /**
+     * Publishing events to observers
+     * It could be either events we get from RAFT, or custom events related to the app
+     */
+    publish(eventType: string, eventEnum: RaftConnEvent | RaftUpdateEvent | RaftPublishEvent | RaftInfoEvents, eventName: string, eventData: any): void;
+    subscribe(observer: RaftObserver, topics: Array<string>): void;
+    unsubscribe(observer: RaftObserver): void;
+    /**
+    * Gets the RSSI of the RAFT
+    */
+    getRSSI(): number;
+    /**
+     * Gets the battery strength of the RAFT
+     */
+    getBatteryStrength(): number;
+    /**
+     * Gets the version of the RAFT
+     */
+    getRaftVersion(): string;
+    /**
+     * Gets the Serial Number of the RAFT
+     */
+    getSerialNumber(): string;
+    /**
+     * Gets the Friendly name of the RAFT
+     */
+    getFriendlyName(): string | undefined;
+    /**
+     * Stream audio to the RAFT
+     */
+    streamAudio(streamContents: Uint8Array, clearExisting: boolean, duration: number): Promise<boolean>;
+    /**
+     * Handles RAFT events
+     * (to be implemented in child classes)
+     */
+    handleRaftEvent(eventType: string, eventEnum: RaftConnEvent | RaftUpdateEvent | RaftPublishEvent | RaftInfoEvents, eventName: string, eventData: any): void;
+    /**
+     * Connection Event Handler
+     */
+    _connectionEventHandler(eventEnum: RaftConnEvent, eventName: string, data: any): Promise<void>;
+    /**
+    * Pub Event Handler
+    */
+    _pubEventHandler(eventEnum: RaftPublishEvent, eventName: string, data: any): Promise<void>;
+    /**
+     * Raft Info Event Handler
+     */
+    _raftInfoEventHandler(eventEnum: RaftInfoEvents, eventName: string, data: any): Promise<void>;
+}

package/dist-types/src/application/RAFTs/RAFT.js

@@ -0,0 +1,341 @@
+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 { AppSentMessage } from "../../types/communication-between-apps/wrapper-communication";
+import { RaftTypeE } from "../../types/raft";
+import { RaftInfoEvents } from "../../types/events/raft-info";
+import { RaftConnEvent, RaftPublishEvent, } from "@robotical/raftjs";
+var RAFT = /** @class */ (function () {
+    function RAFT(id) {
+        this.id = id;
+        this.type = RaftTypeE.undefined;
+        this._ledLcdColours = [{ led: "#000000", lcd: "#000000" }];
+        // Observers
+        this._observers = {};
+        // Is the RAFT serial number registered in warranty
+        this.isSerialNoRegisteredInWarranty = null;
+        // System Info
+        this.systemInfo = null;
+        // RAFT State Info
+        this.raftStateInfo = null;
+    }
+    Object.defineProperty(RAFT.prototype, "ledLcdColours", {
+        /**
+         * Method to get ledLcdColours, to be implemented in child classes.
+         */
+        get: function () {
+            throw new Error("RAFT.tsx: ledLcdColours: Method should be implemented in child class");
+            return this._ledLcdColours;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    /**
+     * Check if RAFT is connected
+     * Sends a message to the Wrapper RICConnector and waits for a response
+     */
+    RAFT.prototype.getIsConnectedFresh = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var isConnected;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, window.wrapperCommunicator.sendMessageAndWait(AppSentMessage.RAFT_IS_CONNECTED, { raftId: this.id })];
+                    case 1:
+                        isConnected = _a.sent();
+                        return [2 /*return*/, isConnected];
+                }
+            });
+        });
+    };
+    /**
+    * Connect to a RAFT
+    * We first connect, then we discover the raft type, and then we create the appopriate raft instance
+    */
+    RAFT.connect = function (method, uuids) {
+        return __awaiter(this, void 0, void 0, function () {
+            var connectResults;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, window.wrapperCommunicator.sendMessageAndWait(AppSentMessage.RAFT_CONNECT, { method: method, uuids: uuids })];
+                    case 1:
+                        connectResults = _a.sent();
+                        return [2 /*return*/, connectResults];
+                }
+            });
+        });
+    };
+    /**
+     * Disconnect from a RAFT
+     */
+    RAFT.prototype.disconnect = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, window.wrapperCommunicator.sendMessageAndWait(AppSentMessage.RAFT_DISCONNECT, { raftId: this.id })];
+            });
+        });
+    };
+    /**
+     * Get RAFT name
+     */
+    RAFT.prototype.getRaftName = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var raftName;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, window.wrapperCommunicator.sendMessageAndWait(AppSentMessage.RAFT_GET_NAME, { raftId: this.id })];
+                    case 1:
+                        raftName = _a.sent();
+                        return [2 /*return*/, raftName];
+                }
+            });
+        });
+    };
+    /**
+    * Verify correct RAFT is selected for phone app
+    */
+    RAFT.prototype.verifyRaftPhoneApp = function (discoveredDevice) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, window.wrapperCommunicator.sendMessageAndWait(AppSentMessage.RAFT_VERIFY_PHONE, { ledLcdColours: this.ledLcdColours, discoveredDevice: discoveredDevice, raftId: this.id })];
+            });
+        });
+    };
+    /**
+    * Verify correct RAFT is selected
+    */
+    RAFT.prototype.verifyRaft = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, window.wrapperCommunicator.sendMessageAndWait(AppSentMessage.RAFT_VERIFY, { ledLcdColours: this.ledLcdColours, raftId: this.id })];
+            });
+        });
+    };
+    /**
+     * Stops the verification process
+     */
+    RAFT.prototype.stopVerifyingRaft = function (isCorrectRIC) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, window.wrapperCommunicator.sendMessageAndWait(AppSentMessage.RAFT_STOP_VERIFY, { isCorrectRIC: isCorrectRIC, raftId: this.id })];
+            });
+        });
+    };
+    /**
+     * Receiveds events from the RICConnector
+     */
+    RAFT.prototype.receivedRICEvent = function (eventType, eventEnum, eventName, eventData) {
+        this.publish(eventType, eventEnum, eventName, eventData);
+        this.handleRaftEvent(eventType, eventEnum, eventName, eventData);
+    };
+    /**
+     * Send a REST message to the RAFT
+     */
+    RAFT.prototype.sendRestMessage = function (msg, params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, window.wrapperCommunicator.sendMessageAndWait(AppSentMessage.RAFT_SEND_REST, { raftId: this.id, msg: msg, params: params })];
+            });
+        });
+    };
+    /**
+     * Highlights the raft
+     */
+    RAFT.prototype.highlight = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                throw new Error("'highlight' Method should be implemented in child class");
+            });
+        });
+    };
+    /**
+     * Publishing events to observers
+     * It could be either events we get from RAFT, or custom events related to the app
+     */
+    RAFT.prototype.publish = function (eventType, eventEnum, eventName, 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);
+            }
+        }
+    };
+    // RAFT observer
+    RAFT.prototype.subscribe = function (observer, topics) {
+        for (var _i = 0, topics_1 = topics; _i < topics_1.length; _i++) {
+            var topic = topics_1[_i];
+            if (!this._observers[topic]) {
+                this._observers[topic] = [];
+            }
+            if (this._observers[topic].indexOf(observer) === -1) {
+                this._observers[topic].push(observer);
+            }
+        }
+    };
+    RAFT.prototype.unsubscribe = function (observer) {
+        for (var topic in this._observers) {
+            if (this._observers.hasOwnProperty(topic)) {
+                var index = this._observers[topic].indexOf(observer);
+                if (index !== -1) {
+                    this._observers[topic].splice(index, 1);
+                }
+            }
+        }
+    };
+    /**
+    * Gets the RSSI of the RAFT
+    */
+    RAFT.prototype.getRSSI = function () {
+        throw new Error("Method will be implemented in child class");
+        return 0;
+    };
+    /**
+     * Gets the battery strength of the RAFT
+     */
+    RAFT.prototype.getBatteryStrength = function () {
+        throw new Error("Method will be implemented in child class");
+        return 0;
+    };
+    /**
+     * Gets the version of the RAFT
+     */
+    RAFT.prototype.getRaftVersion = function () {
+        var _a;
+        return ((_a = this.systemInfo) === null || _a === void 0 ? void 0 : _a.SystemVersion) || "";
+    };
+    /**
+     * Gets the Serial Number of the RAFT
+     */
+    RAFT.prototype.getSerialNumber = function () {
+        var _a;
+        return ((_a = this.systemInfo) === null || _a === void 0 ? void 0 : _a.SerialNo) || "";
+    };
+    /**
+     * Gets the Friendly name of the RAFT
+     */
+    RAFT.prototype.getFriendlyName = function () {
+        var _a;
+        return (_a = this.systemInfo) === null || _a === void 0 ? void 0 : _a.Friendly;
+    };
+    /**
+     * Stream audio to the RAFT
+     */
+    RAFT.prototype.streamAudio = function (streamContents, clearExisting, duration) {
+        return window.wrapperCommunicator.sendMessageAndWait(AppSentMessage.RAFT_STREAM_AUDIO, { raftId: this.id, streamContents: Array.from(streamContents), clearExisting: clearExisting, duration: duration });
+    };
+    /**
+     * Handles RAFT events
+     * (to be implemented in child classes)
+     */
+    RAFT.prototype.handleRaftEvent = function (eventType, eventEnum, eventName, eventData) {
+        switch (eventType) {
+            case "conn":
+                this._connectionEventHandler(eventEnum, eventName, eventData);
+                break;
+            case "pub":
+                this._pubEventHandler(eventEnum, eventName, eventData);
+                break;
+            case "raftinfo":
+                this._raftInfoEventHandler(eventEnum, eventName, eventData);
+                break;
+            default:
+                break;
+        }
+    };
+    /**
+     * Connection Event Handler
+     */
+    RAFT.prototype._connectionEventHandler = function (eventEnum, eventName, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (eventEnum) {
+                    case RaftConnEvent.CONN_VERIFIED_CORRECT:
+                        window.applicationManager.analyticsManager.logEvent("connection", { raftType: this.type, systemInfo: this.systemInfo });
+                        break;
+                    case RaftConnEvent.CONN_DISCONNECTED:
+                        window.applicationManager.analyticsManager.logEvent("disconnection", { raftType: this.type });
+                        break;
+                    case RaftConnEvent.CONN_ISSUE_DETECTED:
+                        window.applicationManager.analyticsManager.logEvent("connection_issue", { data: data });
+                        break;
+                    case RaftConnEvent.CONN_ISSUE_RESOLVED:
+                        window.applicationManager.analyticsManager.logEvent("connection_issue_resolved", { data: data });
+                        break;
+                    default:
+                        break;
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+    * Pub Event Handler
+    */
+    RAFT.prototype._pubEventHandler = function (eventEnum, eventName, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (eventEnum) {
+                    case RaftPublishEvent.PUBLISH_EVENT_DATA:
+                        break;
+                    default:
+                        break;
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    /**
+     * Raft Info Event Handler
+     */
+    RAFT.prototype._raftInfoEventHandler = function (eventEnum, eventName, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (eventEnum) {
+                    case RaftInfoEvents.STATE_INFO:
+                        this.raftStateInfo = data.stateInfo;
+                        break;
+                    case RaftInfoEvents.SYSTEM_INFO:
+                        this.systemInfo = data.systemInfo;
+                        break;
+                    default:
+                        break;
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    return RAFT;
+}());
+export default RAFT;

package/dist-types/src/application/RAFTs/RAFTInterface.d.ts

@@ -0,0 +1,13 @@
+import { RaftTypeE } from "../../types/raft";
+import { RaftConnEvent, RaftPublishEvent, RaftUpdateEvent } from "@robotical/raftjs";
+import { RaftInfoEvents } from "../../types/events/raft-info";
+import { RICLedLcdColours } from "@robotical/roboticaljs";
+export default abstract class RICInterface {
+    abstract type: RaftTypeE;
+    abstract _ledLcdColours: RICLedLcdColours;
+    abstract get ledLcdColours(): RICLedLcdColours;
+    abstract handleRaftEvent(eventType: string, eventEnum: RaftConnEvent | RaftUpdateEvent | RaftPublishEvent | RaftInfoEvents, eventName: string, eventData: any): void;
+    abstract getRSSI(): number;
+    abstract getBatteryStrength(): number;
+    abstract highlight(): void;
+}

package/dist-types/src/application/RAFTs/RAFTInterface.js

@@ -0,0 +1,6 @@
+var RICInterface = /** @class */ (function () {
+    function RICInterface() {
+    }
+    return RICInterface;
+}());
+export default RICInterface;

package/dist-types/src/application/RAFTs/RaftObserver.d.ts

@@ -0,0 +1,10 @@
+import { RaftInfoEvents } from "../../types/events/raft-info";
+import { RaftConnEvent, RaftUpdateEvent, RaftPublishEvent } from "@robotical/raftjs";
+export interface MartyObservable {
+    subscribe(observer: RaftObserver, topics: Array<string>): void;
+    unsubscribe(observer: RaftObserver): void;
+    publish(eventType: string, eventEnum: RaftConnEvent | RaftUpdateEvent | RaftPublishEvent | RaftInfoEvents, eventName: string, eventData: any): void;
+}
+export interface RaftObserver {
+    notify(eventType: string, eventEnum: RaftConnEvent | RaftUpdateEvent | RaftPublishEvent | RaftInfoEvents, eventName: string, eventData: any): void;
+}

package/dist-types/src/application/RAFTs/RaftObserver.js

@@ -0,0 +1 @@
+export {};