@robotical/webapp-types 1.0.0

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

@@ -0,0 +1,69 @@
+import { RaftInfoEvents } from "../../types/events/raft-info";
+import { ConnectionAttemptResults, RaftTypeE } from "../../types/raft";
+import ConnectorInterface from "./ConnectorInterface";
+import { ConnManager, RICLedLcdColours } from "@robotical/roboticaljs";
+import { RaftOKFail, RaftConnEvent, RaftUpdateEvent, RaftPublishEvent } from "@robdobsn/raftjs";
+declare class Connector implements ConnectorInterface {
+    id: string;
+    type: RaftTypeE;
+    private _observers;
+    connManager: ConnManager;
+    constructor(id: string, connManager: ConnManager);
+    /**
+     * Connect to a RAFT after having found the RAFT type
+     */
+    connect(): Promise<ConnectionAttemptResults>;
+    /**
+     * Get connected raft info
+     */
+    getSystemInfo(): Promise<import("@robdobsn/raftjs").RaftSystemInfo>;
+    /**
+     * Gets the RAFT name
+     */
+    getRaftName(): Promise<string>;
+    /**
+     * Send a REST message to the RAFT
+     */
+    sendRestMessage(msg: string, params?: object): Promise<RaftOKFail>;
+    /**
+     * Verify correct RAFT is selected
+     */
+    verifyRaft(ledLcdColours: RICLedLcdColours): Promise<boolean>;
+    /**
+     * Disconnect from a RAFT
+     */
+    disconnect(): Promise<boolean>;
+    /**
+     * Stop verifying RAFT
+     * @param confirmCorrectRIC - indicates if the correct RAFT was selected (user input)
+     */
+    stopVerifyingRaft(confirmCorrectRIC: boolean): Promise<boolean>;
+    /**
+     * Audio streaming
+     */
+    streamAudio(streamContents: Uint8Array, clearExisting: boolean, duration: number): Promise<void>;
+    /**
+     * Publish an event to all observers
+     * Set in RICConnector as an event listener callback
+     */
+    publish(eventType: string, eventEnum: RaftConnEvent | RaftUpdateEvent | RaftPublishEvent | RaftInfoEvents, eventName: string, eventData: any): void;
+    /**
+    * Event handler
+    */
+    eventHandler(eventType: string, eventEnum: RaftConnEvent | RaftUpdateEvent | RaftPublishEvent | RaftInfoEvents, eventName: string, data: any): Promise<void>;
+    /**
+     * Connection Event Handler
+     * This handles the events that are the same for all RAFT systems (e.g., Marty, Cog, etc.)
+     * While the system-specific events are handled in the system-specific connectors
+     */
+    _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 Connector;

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

@@ -0,0 +1,315 @@
+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 { RaftInfoEvents } from "../../types/events/raft-info";
+import { WrapperSentMessage } from "../../types/communication-between-apps/wrapper-communication";
+import Logger from "../../services/logger/Logger";
+import { RaftTypeE } from "../../types/raft";
+import { RaftConnEvent, RaftUpdateEvent, RaftPublishEvent } from "@robdobsn/raftjs";
+var SHOW_LOGS = true;
+var TAG = "Connector";
+var Connector = /** @class */ (function () {
+    function Connector(id, connManager) {
+        var _this = this;
+        this.id = id;
+        this.type = RaftTypeE.undefined;
+        // RAFT
+        // Observers
+        this._observers = {};
+        this.connManager = connManager;
+        // Set the listener function
+        // Subscribe to connManager events
+        this.connManager.setConnectionEventListener(function (eventType, eventEnum, eventName, eventData) {
+            if (eventType !== "pub") {
+                Logger.info(SHOW_LOGS, TAG, "eventType: ".concat(eventType, " eventEnum: ").concat(eventEnum, " eventName: ").concat(eventName, " eventData: ").concat(eventData));
+            }
+            _this.eventHandler(eventType, eventEnum, eventName, eventData);
+            _this.publish(eventType, eventEnum, eventName, eventData);
+        });
+    }
+    /**
+     * Connect to a RAFT after having found the RAFT type
+     */
+    Connector.prototype.connect = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                throw new Error("Method should be implemented in child class");
+            });
+        });
+    };
+    /**
+     * Get connected raft info
+     */
+    Connector.prototype.getSystemInfo = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.connManager.getConnector().getRaftSystemUtils().getSystemInfo()];
+            });
+        });
+    };
+    /**
+     * Gets the RAFT name
+     */
+    Connector.prototype.getRaftName = function () {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_b) {
+                return [2 /*return*/, ((_a = this.connManager.getConnector().getRaftSystemUtils().getFriendlyName()) === null || _a === void 0 ? void 0 : _a.friendlyName) || ""];
+            });
+        });
+    };
+    /**
+     * Send a REST message to the RAFT
+     */
+    Connector.prototype.sendRestMessage = function (msg, params) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.connManager.getConnector().sendRICRESTMsg(msg, params || {})];
+            });
+        });
+    };
+    /**
+     * Verify correct RAFT is selected
+     */
+    Connector.prototype.verifyRaft = function (ledLcdColours) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var msgHandler, onConnEvent, isConnectedFn;
+            return __generator(this, function (_b) {
+                msgHandler = this.connManager.getConnector().getRaftSystemUtils().getMsgHandler();
+                onConnEvent = this.connManager.getConnector().onConnEvent.bind(this.connManager.getConnector());
+                isConnectedFn = this.connManager.isConnected.bind(this.connManager);
+                return [2 /*return*/, (_a = this.connManager.getConnector().getSystemType()) === null || _a === void 0 ? void 0 : _a.getLEDPatternChecker().checkCorrectRICStart(ledLcdColours, msgHandler, onConnEvent, isConnectedFn)];
+            });
+        });
+    };
+    /**
+     * Disconnect from a RAFT
+     */
+    Connector.prototype.disconnect = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: 
+                    // this.sendRestMessage('blerestart');
+                    return [4 /*yield*/, this.connManager.disconnect()];
+                    case 1:
+                        // this.sendRestMessage('blerestart');
+                        _a.sent();
+                        return [2 /*return*/, true];
+                }
+            });
+        });
+    };
+    /**
+     * Stop verifying RAFT
+     * @param confirmCorrectRIC - indicates if the correct RAFT was selected (user input)
+     */
+    Connector.prototype.stopVerifyingRaft = function (confirmCorrectRIC) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_b) {
+                if (confirmCorrectRIC) {
+                    // successful connection to RAFT
+                    // const ricSystem = this.connManager.getConnector().getRICSystem();
+                    // await ricSystem.getRICSystemInfo(true);
+                    // this.publish("conn", RaftInfoEvents.SYSTEM_INFO, "SystemInfo", systemInfo);
+                    // this.publish("conn", RaftInfoEvents.MARTY_VERSION, "MartyVersion", systemInfo.SystemVersion);
+                    // this.publish("conn", RaftInfoEvents.MARTY_SERIAL_NO, "MartySerialNo", systemInfo.SerialNo);
+                    // this.publish("conn", RaftInfoEvents.MARTY_IS_VERIFIED, "MartyIsVerified", true);
+                    // this.analytics_RobotStartSession(systemInfo); TODO: respond to the systemInfo event and call this function
+                    // this.isVerified = true; TODO: this event should be published from RICJS, listen for it in the front-end
+                    // const serialNo = systemInfo.SerialNo!;
+                    // TODO: respond to the MartySerialNo event and call this block
+                    // const isSerialNoRegisteredInWarranty = await isSerialNumberRegistered(serialNo); 
+                    // const dbManager = DatabaseManager.getInstance();
+                    // dbManager.isSerialNoRegisteredInWarranty = isSerialNoRegisteredInWarranty;
+                    // this.isSerialNoRegisteredInWarranty = isSerialNoRegisteredInWarranty;
+                    // if (isSerialNoRegisteredInWarranty) {
+                    //     addMartyNameToSerialNumber(serialNo, this.RICFriendlyName);
+                    // }
+                    // store ble conn performance 
+                    // as promise because we don't want to wait for it to finish
+                    // Promise.resolve().then(async () => {
+                    //     const bleConnPerf = await this.connManager.getConnector().checkConnPerformance();
+                    //     const dbManager = DatabaseManager.getInstance();
+                    //     const appDb = await dbManager.initializeOrGetDatabase(DatabaseEnum.APP, DatabaseEnum.APP) as AppDatabase;
+                    //     bleConnPerf && appDb.storeBlePerformance(bleConnPerf);
+                    //     this.soundStreamingStats.configureSoundStreamingForRobot(systemInfo, bleConnPerf);
+                    // });
+                }
+                return [2 /*return*/, (_a = this.connManager.getConnector().getSystemType()) === null || _a === void 0 ? void 0 : _a.getLEDPatternChecker().checkCorrectRICStop(confirmCorrectRIC)];
+            });
+        });
+    };
+    /**
+     * Audio streaming
+     */
+    Connector.prototype.streamAudio = function (streamContents, clearExisting, duration) {
+        return __awaiter(this, void 0, void 0, function () {
+            var streamContentsNewUint8Array;
+            return __generator(this, function (_a) {
+                streamContentsNewUint8Array = new Uint8Array(streamContents);
+                return [2 /*return*/, this.connManager.getConnector().streamAudio(streamContentsNewUint8Array, clearExisting, duration)];
+            });
+        });
+    };
+    /**
+     * Publish an event to all observers
+     * Set in RICConnector as an event listener callback
+     */
+    Connector.prototype.publish = function (eventType, eventEnum, eventName, eventData) {
+        window.WebAppCommunicator.sendMessageNoWait(WrapperSentMessage.RAFT_PUBLISHED_EVENT, { raftId: this.id, 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);
+            }
+        }
+    };
+    /**
+    * Event handler
+    */
+    Connector.prototype.eventHandler = function (eventType, eventEnum, eventName, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                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
+     * This handles the events that are the same for all RAFT systems (e.g., Marty, Cog, etc.)
+     * While the system-specific events are handled in the system-specific connectors
+     */
+    Connector.prototype._connectionEventHandler = function (eventEnum, eventName, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a, systemInfo, raftName, raftMsgHandler;
+            var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        Logger.info(SHOW_LOGS, TAG, "Event: ".concat(eventEnum, " data: ").concat(data));
+                        _a = eventEnum;
+                        switch (_a) {
+                            case RaftConnEvent.CONN_CONNECTED: return [3 /*break*/, 1];
+                            case RaftConnEvent.CONN_VERIFIED_CORRECT: return [3 /*break*/, 6];
+                        }
+                        return [3 /*break*/, 7];
+                    case 1:
+                        systemInfo = this.connManager.getConnector().getRaftSystemUtils().getCachedSystemInfo();
+                        if (!!systemInfo) return [3 /*break*/, 3];
+                        return [4 /*yield*/, this.connManager.getConnector().getRaftSystemUtils().getSystemInfo()];
+                    case 2:
+                        systemInfo = _b.sent();
+                        _b.label = 3;
+                    case 3:
+                        raftName = this.connManager.getConnector().getRaftSystemUtils().getCachedRaftName() || this.connManager.getConnector().getRaftSystemUtils().getFriendlyName();
+                        if (!!raftName) return [3 /*break*/, 5];
+                        return [4 /*yield*/, this.connManager.getConnector().getRaftSystemUtils().getRaftName()];
+                    case 4:
+                        raftName = _b.sent();
+                        _b.label = 5;
+                    case 5:
+                        systemInfo.Friendly = raftName.friendlyName;
+                        this.publish("raftinfo", RaftInfoEvents.SYSTEM_INFO, "SystemInfo", { systemInfo: systemInfo });
+                        return [3 /*break*/, 8];
+                    case 6:
+                        raftMsgHandler = this.connManager.getConnector().getRaftMsgHandler();
+                        raftMsgHandler.reportMsgCallbacksSet("notifyCB", function (report) { return _this.publish("msg", RaftInfoEvents.RAFT_MSG, "RICMsg", report); });
+                        return [3 /*break*/, 8];
+                    case 7: return [3 /*break*/, 8];
+                    case 8: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Update Event Handler
+     */
+    Connector.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
+     */
+    Connector.prototype._pubEventHandler = function (eventEnum, eventName, data) {
+        return __awaiter(this, void 0, void 0, function () {
+            var systemType, stateInfo;
+            return __generator(this, function (_a) {
+                switch (eventEnum) {
+                    case RaftPublishEvent.PUBLISH_EVENT_DATA:
+                        systemType = this.connManager.getConnector().getSystemType();
+                        if (systemType) {
+                            stateInfo = systemType.getStateInfo();
+                            this.publish("raftinfo", RaftInfoEvents.STATE_INFO, "StateInfo", { stateInfo: stateInfo });
+                        }
+                        break;
+                    default:
+                        break;
+                }
+                return [2 /*return*/];
+            });
+        });
+    };
+    return Connector;
+}());
+export default Connector;

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

@@ -0,0 +1,15 @@
+import { ConnManager } from "@robotical/roboticaljs";
+import { RaftConnectionMethod } from "../../types/raft";
+import Connector from "./Connector";
+export default class ConnectorFactory {
+    /**
+     * 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>
+     *
+     */
+    static connectToRaftHelper(method: RaftConnectionMethod): Promise<Connector | null>;
+    static createConnector(raftType: string | undefined, connManager: ConnManager): Connector;
+}

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

@@ -0,0 +1,99 @@
+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 { ConnManager } from "@robotical/roboticaljs";
+import randomHashGenerator from "../../utils/helpers/randomHashGenerator";
+import CogConnector from "./CogConnector/CogConnector";
+import MartyConnector from "./MartyConnector/MartyConnector";
+import Logger from "../../services/logger/Logger";
+var SHOW_LOGS = true;
+var TAG = "ConnectorFactory";
+var ConnectorFactory = /** @class */ (function () {
+    function ConnectorFactory() {
+    }
+    /**
+     * 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>
+     *
+     */
+    ConnectorFactory.connectToRaftHelper = function (method) {
+        return __awaiter(this, void 0, void 0, function () {
+            var connManager, wasConnected, systemInfo, raftType, connector;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        connManager = new ConnManager();
+                        Logger.info(SHOW_LOGS, TAG, "Connecting to RAFT with method: ".concat(method));
+                        return [4 /*yield*/, connManager.connect(method, "")];
+                    case 1:
+                        wasConnected = _a.sent();
+                        Logger.info(SHOW_LOGS, TAG, "Was connected to RAFT: ".concat(wasConnected));
+                        if (!wasConnected) {
+                            return [2 /*return*/, null];
+                        }
+                        systemInfo = connManager.getConnector().getRaftSystemUtils().getCachedSystemInfo();
+                        raftType = systemInfo === null || systemInfo === void 0 ? void 0 : systemInfo.SystemName;
+                        connector = this.createConnector(raftType, connManager);
+                        return [2 /*return*/, connector];
+                }
+            });
+        });
+    };
+    ConnectorFactory.createConnector = function (raftType, connManager) {
+        var systemInfo = connManager.getConnector().getRaftSystemUtils().getCachedSystemInfo();
+        var serialNo = systemInfo === null || systemInfo === void 0 ? void 0 : systemInfo.SerialNo;
+        var connector;
+        var randomId = serialNo || randomHashGenerator();
+        switch (raftType) {
+            case "RIC":
+                connector = new MartyConnector(randomId, connManager);
+                break;
+            case "Cog":
+                connector = new CogConnector(randomId, connManager);
+                break;
+            case "Axiom":
+                throw new Error("Axiom not supported yet");
+            default:
+                throw new Error("Unknown RAFT type");
+        }
+        return connector;
+    };
+    return ConnectorFactory;
+}());
+export default ConnectorFactory;

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

@@ -0,0 +1,10 @@
+import { RaftConnEvent, RaftPublishEvent, RaftUpdateEvent } from "@robdobsn/raftjs";
+import { ConnectionAttemptResults, RaftTypeE } from "../../types/raft";
+import { RaftInfoEvents } from "../../types/events/raft-info";
+import { RICLedLcdColours } from "@robotical/roboticaljs";
+export default abstract class ConnectorInterface {
+    abstract type: RaftTypeE;
+    abstract eventHandler: (eventType: string, eventEnum: RaftConnEvent | RaftUpdateEvent | RaftPublishEvent | RaftInfoEvents, eventName: string, eventData: any) => void;
+    abstract verifyRaft(ledLcdColours: RICLedLcdColours): Promise<boolean>;
+    abstract connect(): Promise<ConnectionAttemptResults>;
+}

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

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

package/dist-types/src/wrapper-app/connectors/MartyConnector/MartyConnector.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, RaftUpdateEvent, RaftPublishEvent } from "@robdobsn/raftjs";
+import { ConnManager } from "@robotical/roboticaljs";
+declare class MartyConnector extends Connector implements ConnectorInterface {
+    type: RaftTypeE;
+    constructor(raftId: string, connManager: ConnManager);
+    /**
+     * Connect to a RAFT
+     */
+    connect(): Promise<ConnectionAttemptResults>;
+    /**
+     * Disconnect from Marty
+     */
+    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 MartyConnector;