@robotical/webapp-types 0.6.58

package/dist-types/src/types/raft.d.ts

@@ -0,0 +1,18 @@
+export declare enum RaftConnectionMethod {
+    WEB_SOCKET = "WebSocket",
+    WEB_BLE = "WebBLE",
+    PHONE_BLE = "PhoneBLE"
+}
+export type ConnectionAttemptResults = {
+    success: boolean;
+    reason: 'failed' | 'unplugged' | 'success' | 'no_sys_info' | 'invalid_raft_type';
+    data?: {
+        raftId: string;
+        raftType: RaftTypeE;
+    };
+};
+export declare enum RaftTypeE {
+    MARTY = "Marty",
+    COG = "Cog",
+    undefined = "undefined"
+}

package/dist-types/src/types/raft.js

@@ -0,0 +1,14 @@
+export var RaftConnectionMethod;
+(function (RaftConnectionMethod) {
+    RaftConnectionMethod["WEB_SOCKET"] = "WebSocket";
+    RaftConnectionMethod["WEB_BLE"] = "WebBLE";
+    RaftConnectionMethod["PHONE_BLE"] = "PhoneBLE";
+})(RaftConnectionMethod || (RaftConnectionMethod = {}));
+;
+export var RaftTypeE;
+(function (RaftTypeE) {
+    RaftTypeE["MARTY"] = "Marty";
+    RaftTypeE["COG"] = "Cog";
+    RaftTypeE["undefined"] = "undefined";
+})(RaftTypeE || (RaftTypeE = {}));
+;

package/dist-types/src/utils/Toaster.d.ts

@@ -0,0 +1,13 @@
+import { ToastOptions } from 'react-toastify';
+import 'react-toastify/dist/ReactToastify.css';
+declare class Toaster {
+    private static lastToastTime;
+    private static debounceTime;
+    private static shouldShowToast;
+    static warn(message: string, options?: ToastOptions): void;
+    static error(message: string, options?: ToastOptions): void;
+    static info(message: string, options?: ToastOptions): void;
+    static success(message: string, options?: ToastOptions): void;
+    static clearAll(): void;
+}
+export default Toaster;

package/dist-types/src/utils/Toaster.js

@@ -0,0 +1,38 @@
+import { toast } from 'react-toastify';
+import 'react-toastify/dist/ReactToastify.css';
+var Toaster = /** @class */ (function () {
+    function Toaster() {
+    }
+    Toaster.shouldShowToast = function (message) {
+        var currentTime = Date.now();
+        var lastTimeShown = this.lastToastTime.get(message) || 0;
+        var shouldBeShown = currentTime - lastTimeShown > this.debounceTime;
+        if (shouldBeShown) {
+            this.lastToastTime.set(message, currentTime);
+        }
+        return shouldBeShown;
+    };
+    Toaster.warn = function (message, options) {
+        if (this.shouldShowToast(message))
+            toast.warn(message, options);
+    };
+    Toaster.error = function (message, options) {
+        if (this.shouldShowToast(message))
+            toast.error(message, options);
+    };
+    Toaster.info = function (message, options) {
+        if (this.shouldShowToast(message))
+            toast.info(message, options);
+    };
+    Toaster.success = function (message, options) {
+        if (this.shouldShowToast(message))
+            toast.success(message, options);
+    };
+    Toaster.clearAll = function () {
+        toast.dismiss();
+    };
+    Toaster.lastToastTime = new Map();
+    Toaster.debounceTime = 5000;
+    return Toaster;
+}());
+export default Toaster;

package/dist-types/src/utils/helpers/compare-version.d.ts

@@ -0,0 +1,2 @@
+export default function isVersionGreater(v1: string, v2: string): boolean;
+export declare function isVersionGreater_errorCatching(v1: string, v2: string): boolean | null;

package/dist-types/src/utils/helpers/compare-version.js

@@ -0,0 +1,19 @@
+import semverGt from "semver/functions/gt";
+export default function isVersionGreater(v1, v2) {
+    try {
+        return semverGt(v1, v2);
+    }
+    catch (e) {
+        console.log(e, v1, v2);
+        return false;
+    }
+}
+export function isVersionGreater_errorCatching(v1, v2) {
+    try {
+        return semverGt(v1, v2);
+    }
+    catch (e) {
+        console.log(e, v1, v2);
+        return null;
+    }
+}

package/dist-types/src/utils/helpers/randomHashGenerator.d.ts

@@ -0,0 +1 @@
+export default function (length?: number): string;

package/dist-types/src/utils/helpers/randomHashGenerator.js

@@ -0,0 +1,10 @@
+export default function (length) {
+    if (length === void 0) { length = 10; }
+    var result = "";
+    var characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+    var charactersLength = characters.length;
+    for (var i = 0; i < length; i++) {
+        result += characters.charAt(Math.floor(Math.random() * charactersLength));
+    }
+    return result;
+}

package/dist-types/src/utils/helpers/rescale-range.d.ts

@@ -0,0 +1,2 @@
+declare const rescale: (x: number, oldMin: number, oldMax: number, newMin: number, newMax: number) => number;
+export default rescale;

package/dist-types/src/utils/helpers/rescale-range.js

@@ -0,0 +1,4 @@
+var rescale = function (x, oldMin, oldMax, newMin, newMax) {
+    return ((newMax - newMin) / (oldMax - oldMin)) * (x - oldMin) + newMin;
+};
+export default rescale;

package/dist-types/src/utils/helpers/wifi-configuration-subtitle-gen.d.ts

@@ -0,0 +1,3 @@
+import RAFT from "../../application/RAFTs/RAFT";
+export declare const FW_VERSION_RSSI_WIFI = "1.2.0";
+export default function wifiConfigSub(raft: RAFT): "" | "Currently, wifi configuration only works in the phone application.";

package/dist-types/src/utils/helpers/wifi-configuration-subtitle-gen.js

@@ -0,0 +1,34 @@
+import isVersionGreater from "./compare-version";
+export var FW_VERSION_RSSI_WIFI = "1.2.0"; // greater versions than this (1.1.17) have the wifi rssi logic
+export default function wifiConfigSub(raft) {
+    if (!isVersionGreater(raft.getRaftVersion(), FW_VERSION_RSSI_WIFI)) {
+        return "Currently, wifi configuration only works in the phone application.";
+    }
+    return "";
+    // const isPaused = window.marty.getCachedWifiStatus().ssid ? true : false;
+    // const conInfo =
+    //   window.marty.getCachedWifiStatus().connState ===
+    //     RICWifiConnState.WIFI_CONN_CONNECTED ||
+    //   window.marty.getCachedWifiStatus().ssid
+    //     ? window.marty.getCachedWifiStatus().ipAddress +
+    //       " on " +
+    //       window.marty.getCachedWifiStatus().ssid
+    //     : null;
+    // const isConnected =
+    //   window.marty.getCachedWifiStatus().connState ===
+    //   RICWifiConnState.WIFI_CONN_CONNECTED;
+    // let subtitle;
+    // if (isConnected) {
+    //   subtitle = "Connected";
+    // }
+    // if (isPaused) {
+    //   subtitle = "Connected (Paused for BLE)";
+    // }
+    // if (!isConnected && !isPaused) {
+    //   subtitle = "Not Connected";
+    // }
+    // if (conInfo) {
+    //   subtitle += " | " + conInfo;
+    // }
+    // return subtitle;
+}

package/dist-types/src/utils/phone-app-communication/is-phone-app.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Checks if the current app instance is from the phone application
+ */
+declare const isPhoneApp: () => boolean;
+export default isPhoneApp;

package/dist-types/src/utils/phone-app-communication/is-phone-app.js

@@ -0,0 +1,7 @@
+/**
+ * Checks if the current app instance is from the phone application
+ */
+var isPhoneApp = function () {
+    return !!window.ReactNativeWebView;
+};
+export default isPhoneApp;

package/dist-types/src/wrapper-app/WrapperAppManager.d.ts

@@ -0,0 +1,58 @@
+import { RaftInfoEvents } from "../types/events/raft-info";
+import { ConnectionAttemptResults, RaftConnectionMethod } from "../types/raft";
+import { RaftConnEvent, RaftPublishEvent, RaftUpdateEvent } from "@robotical/raftjs";
+import { RICLedLcdColours } from "@robotical/roboticaljs";
+export declare class WrapperAppManager {
+    private connectors;
+    private _observers;
+    constructor();
+    /**
+    * 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>
+    *
+    */
+    connect(method: RaftConnectionMethod, uuids: string[]): Promise<ConnectionAttemptResults>;
+    /**
+     * Re-triggers the connect event which was missed due to the connection logic
+     */
+    getMissedConnEvent(raftId: any): void;
+    /**
+     * Get the RAFT Name
+     */
+    getRaftName(raftId: string): "" | Promise<string>;
+    /**
+     * Verify RAFT
+     */
+    verifyRaft(ledLcdColours: RICLedLcdColours, raftId: string): false | Promise<boolean>;
+    /**
+     * Stop verifying RAFT
+     */
+    stopVerifyingRaft(isCorrectRIC: boolean, raftId: string): Promise<boolean>;
+    /**
+     * Disconnect from a RAFT
+     */
+    disconnect(raftId: string): Promise<boolean>;
+    /**
+     * Audio streaming
+     */
+    streamAudio(raftId: string, 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;
+    /**
+     * Send a REST message to the RAFT
+     */
+    sendRestMessage(msg: string, params: object | undefined, raftId: string): Promise<import("@robotical/raftjs").RaftOKFail>;
+    /**
+     * Removes marty after a certain time
+     * Removes from the martys list after x seconds so that we can still get the last event
+     */
+    _removeRICConnector(connectorId: string, timeout: number): void;
+}
+declare const wrapperAppManager: WrapperAppManager;
+export default wrapperAppManager;

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 "@robotical/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, uuids) {
+        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, uuids)];
+                    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, 3000);
+        }
+        return this.connectors[raftId].stopVerifyingRaft(isCorrectRIC);
+    };
+    /**
+     * Disconnect from a RAFT
+     */
+    WrapperAppManager.prototype.disconnect = function (raftId) {
+        this._removeRICConnector(raftId, 3000);
+        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;