@robotical/webapp-types 1.0.0

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

@@ -0,0 +1,313 @@
+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 { RaftPublishEvent, } from "@robdobsn/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) {
+        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 })];
+                    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 (discoveredRIC) {
+        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, discoveredRIC: discoveredRIC, 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 "pub":
+                this._pubEventHandler(eventEnum, eventName, eventData);
+                break;
+            case "raftinfo":
+                this._raftInfoEventHandler(eventEnum, eventName, eventData);
+                break;
+            default:
+                break;
+        }
+    };
+    /**
+    * 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 "@robdobsn/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 "@robdobsn/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 {};

package/dist-types/src/application/RAFTs/raft-subscription-helpers.d.ts

@@ -0,0 +1,59 @@
+import RAFT from "./RAFT";
+/**
+ * Connection Verifying Subscription Helper
+ */
+export declare const raftConnectingSubscriptionHelper: (raft: RAFT) => {
+    subscribe: (callback: any) => void;
+    unsubscribe: () => void;
+};
+/**
+ * RAFT Connected Subscription Helper
+ */
+export declare const raftConnectedSubscriptionHelper: (raft: RAFT) => {
+    subscribe: (callback: any) => void;
+    unsubscribe: () => void;
+};
+/**
+ * RAFT Disconnected Subscription Helper
+ */
+export declare const raftDisconnectedSubscriptionHelper: (raft: RAFT) => {
+    subscribe: (callback: any) => void;
+    unsubscribe: () => void;
+};
+/**
+ * RAFT Verified Subscription Helper
+ */
+export declare const raftVerifiedSubscriptionHelper: (raft: RAFT) => {
+    subscribe: (callback: any) => void;
+    unsubscribe: () => void;
+};
+/**
+ * Subscription Helper for raftFound event
+ * ApplicationManager
+ */
+export declare const raftFoundSubscriptionHelper: () => {
+    subscribe: (callback: any) => void;
+    unsubscribe: () => void;
+};
+/**
+ * Subscription Helper for raftDiscoveryFinished event
+ */
+export declare const raftDiscoveryFinishedSubscriptionHelper: () => {
+    subscribe: (callback: any) => void;
+    unsubscribe: () => void;
+};
+/**
+ * Subscription Helper for raftDiscoveryStarted event
+ */
+export declare const raftDiscoveryStartedSubscriptionHelper: () => {
+    subscribe: (callback: any) => void;
+    unsubscribe: () => void;
+};
+/**
+ * Subscription Helper for raftRejected event
+ * This event is triggered when the RAFT is rejected during the verification process
+ */
+export declare const raftRejectedSubscriptionHelper: (raft: RAFT) => {
+    subscribe: (callback: any) => void;
+    unsubscribe: () => void;
+};