@robotical/webapp-types 1.0.0

package/dist-types/src/state-observables/modal/ModalState.js

@@ -0,0 +1,69 @@
+var ModalState = /** @class */ (function () {
+    function ModalState() {
+        this._observers = {};
+        this._modalPromise = null;
+        this._modalResolve = function () { };
+        this._modalReject = function () { };
+    }
+    ModalState.prototype.setModal = function (modalContent, modalTitle) {
+        var _this = this;
+        this._modalPromise = new Promise(function (resolve, reject) {
+            _this._modalResolve = resolve;
+            _this._modalReject = reject;
+            _this.modalContent = modalContent;
+            _this.modalTitle = modalTitle;
+            _this.publish("SetModal", { modalContent: modalContent, modalTitle: modalTitle });
+        });
+        return this._modalPromise;
+    };
+    ModalState.prototype.closeModal = function (modalReturnValue, onCloseCb) {
+        this.modalContent = null;
+        this.modalTitle = "";
+        this.publish("CloseModal");
+        this._modalResolve(modalReturnValue);
+        this.clearPromise();
+        onCloseCb && onCloseCb();
+    };
+    ModalState.prototype.updateModalProps = function (updatedProps) {
+        this.modalTitle = updatedProps.modalTitle || this.modalTitle;
+        this.publish("UpdateModalProps", updatedProps);
+    };
+    ModalState.prototype.clearPromise = function () {
+        this._modalPromise = null;
+        this._modalResolve = function () { };
+        this._modalReject = function () { };
+    };
+    ModalState.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);
+            }
+        }
+    };
+    ModalState.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);
+                }
+            }
+        }
+    };
+    ModalState.prototype.publish = function (eventTopic, eventData) {
+        if (this._observers.hasOwnProperty(eventTopic)) {
+            for (var _i = 0, _a = this._observers[eventTopic]; _i < _a.length; _i++) {
+                var observer = _a[_i];
+                observer.notify(eventTopic, eventData);
+            }
+        }
+    };
+    return ModalState;
+}());
+var modalState = new ModalState();
+export default modalState;
+export var secondaryModalState = new ModalState();

package/dist-types/src/store/SelectedRaftContext.d.ts

@@ -0,0 +1,17 @@
+export declare enum NewRobotIdE {
+    NEW = "=+__new__+="
+}
+export type ConnectedRaftItem = {
+    id: string;
+    name: string;
+    isSelected: boolean;
+};
+export declare const ConnectedRaftContentProvider: ({ children }: {
+    children: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const useConnectedRafts: () => {
+    connectedRafts: ConnectedRaftItem[];
+    addConnectedRaft: (connectedRaft: ConnectedRaftItem) => void;
+    removeConnectedRaft: (connectedRaftId: string) => void;
+    setSelectedRaft: (connectedRaftId: string) => void;
+};

package/dist-types/src/store/SelectedRaftContext.js

@@ -0,0 +1,80 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext, useEffect, useState } from 'react';
+export var NewRobotIdE;
+(function (NewRobotIdE) {
+    NewRobotIdE["NEW"] = "=+__new__+=";
+})(NewRobotIdE || (NewRobotIdE = {}));
+var ConnectedRaftContext = createContext({
+    connectedRafts: [],
+    addConnectedRaft: function (connectedRaft) { },
+    removeConnectedRaft: function (connectedRaftId) { },
+    setSelectedRaft: function (connectedRaftId) { },
+});
+// Provider component
+export var ConnectedRaftContentProvider = function (_a) {
+    var children = _a.children;
+    var _b = useState([{ id: NewRobotIdE.NEW, isSelected: true, name: "Connect to new robot" }]), connectedRafts = _b[0], setConnectedRafts = _b[1];
+    useEffect(function () {
+        if (window.applicationManager) {
+            window.applicationManager.connectedRaftContextMethods = {
+                addConnectedRaft: function (connectedRaft) {
+                    addConnectedRaft(connectedRaft);
+                },
+                removeConnectedRaft: function (connectedRaftId) {
+                    removeConnectedRaft(connectedRaftId);
+                },
+                setSelectedRaft: function (connectedRaftId) {
+                    setSelectedRaft(connectedRaftId);
+                },
+            };
+        }
+    }, []);
+    var addConnectedRaft = function (connectedRaft) {
+        // if the new raft is already in the list, do not add it again, just select it
+        var existingRaft = connectedRafts.find(function (connectedRaft_) { return connectedRaft_.id === connectedRaft.id; });
+        if (existingRaft) {
+            setConnectedRafts(function (prev) { return prev.map(function (connectedRaft_) { return (__assign(__assign({}, connectedRaft_), { isSelected: connectedRaft_.id === connectedRaft.id })); }); });
+            return;
+        }
+        // if the newly added raft is selected, deselect the previously selected raft
+        if (connectedRaft.isSelected) {
+            setConnectedRafts(function (prev) { return prev.map(function (connectedRaft) { return (__assign(__assign({}, connectedRaft), { isSelected: false })); }); });
+        }
+        setConnectedRafts(function (prev) { return __spreadArray(__spreadArray([], prev, true), [connectedRaft], false); });
+    };
+    var removeConnectedRaft = function (connectedRaftId) {
+        // if the removed raft is selected, select the first raft in the list
+        var selectedRaft = connectedRafts.find(function (connectedRaft) { return connectedRaft.isSelected; });
+        if ((selectedRaft === null || selectedRaft === void 0 ? void 0 : selectedRaft.id) === connectedRaftId) {
+            setConnectedRafts(function (prev) { return prev.map(function (connectedRaft, index) { return (__assign(__assign({}, connectedRaft), { isSelected: index === 0 })); }); });
+        }
+        setConnectedRafts(function (prev) { return prev.filter(function (connectedRaft) { return connectedRaft.id !== connectedRaftId; }); });
+    };
+    var setSelectedRaft = function (connectedRaftId) {
+        // deselect the previously selected raft
+        setConnectedRafts(function (prev) { return prev.map(function (connectedRaft) { return (__assign(__assign({}, connectedRaft), { isSelected: false })); }); });
+        setConnectedRafts(function (prev) { return prev.map(function (connectedRaft) { return (__assign(__assign({}, connectedRaft), { isSelected: connectedRaft.id === connectedRaftId })); }); });
+    };
+    return (_jsx(ConnectedRaftContext.Provider, __assign({ value: { connectedRafts: connectedRafts, addConnectedRaft: addConnectedRaft, removeConnectedRaft: removeConnectedRaft, setSelectedRaft: setSelectedRaft } }, { children: children })));
+};
+export var useConnectedRafts = function () { return useContext(ConnectedRaftContext); };

package/dist-types/src/styles/colors.d.ts

@@ -0,0 +1,35 @@
+export declare const BLACK = "rgb(38,38,38)";
+export declare const BLACK_075 = "rgba(38, 38, 38, 0.75)";
+export declare const BLACK_05 = "rgba(38, 38, 38, 0.5)";
+export declare const BLACK_025 = "rgba(0,0,0, 0.25)";
+export declare const GREY = "rgba(81, 81, 81, 0.5)";
+export declare const GREY_2 = "#f5f5f5";
+export declare const GREY_3 = "rgb(143, 142, 148)";
+export declare const GREY_4 = "rgb(223, 223, 223)";
+export declare const HINT_GREY = "rgba(125,125,125, 0.5)";
+export declare const MAIN_BLUE = "rgb(55, 171, 200)";
+export declare const AQUA_BLUE_025 = "rgba(55, 171, 200, 0.25)";
+export declare const AQUA_BLUE_05 = "rgba(55, 171, 200, 0.5)";
+export declare const PALE_BLUE = "#94cddc";
+export declare const WHITE = "rgb(245,245,245)";
+export declare const TRUE_WHITE = "rgb(255, 255, 255)";
+export declare const PALE_WHITE = "rgba(245,245,245, 0.5)";
+export declare const GREEN = "rgb(0, 213, 146)";
+export declare const RED = "rgb(237, 82, 82)";
+export declare const SAND_YELLOW = "rgb(244, 218,97)";
+export declare const SAND_YELLOW_25 = "rgba(244, 218,97, 0.25)";
+export declare const SAND_YELLOW_50 = "rgba(244, 218, 97, 0.5)";
+export declare const BLUE_LED = "rgba(0, 0, 128, 0.5)";
+export declare const GREEN_LED = "rgba(0, 128, 0, 0.5)";
+export declare const PINK_LED = "rgba(128, 0, 128, 0.5)";
+export declare const DASHBUTTON_BLUE = "rgb(198,234,239)";
+export declare const DASHBORDER_BLUE = "rgb(175,221,233)";
+export declare const INDICATOR_GREEN = "rgb(11, 158, 46)";
+export declare const INDICATOR_ORANGE = "rgb(253, 180, 1)";
+export declare const INDICATOR_RED = "rgb(237, 82, 82)";
+export declare const INDICATOR_WHITE = "rgba(245,245,245, 0.5)";
+export declare const SCREENFREE_PURPLE = "rgb(118, 53, 151)";
+export declare const SCREENFREE_GREEN = "rgb(3, 125, 60)";
+export declare const SCREENFREE_YELLOW = "rgb(250, 217, 5)";
+export declare const SCREENFREE_RED = "rgb(91, 20, 19)";
+export declare const SCREENFREE_BLUE = "rgb(0, 170, 255)";

package/dist-types/src/styles/colors.js

@@ -0,0 +1,42 @@
+export var BLACK = 'rgb(38,38,38)';
+export var BLACK_075 = 'rgba(38, 38, 38, 0.75)';
+export var BLACK_05 = 'rgba(38, 38, 38, 0.5)';
+export var BLACK_025 = 'rgba(0,0,0, 0.25)';
+export var GREY = 'rgba(81, 81, 81, 0.5)';
+export var GREY_2 = '#f5f5f5';
+export var GREY_3 = 'rgb(143, 142, 148)';
+export var GREY_4 = 'rgb(223, 223, 223)';
+export var HINT_GREY = 'rgba(125,125,125, 0.5)';
+export var MAIN_BLUE = 'rgb(55, 171, 200)';
+export var AQUA_BLUE_025 = 'rgba(55, 171, 200, 0.25)';
+export var AQUA_BLUE_05 = 'rgba(55, 171, 200, 0.5)';
+export var PALE_BLUE = '#94cddc';
+export var WHITE = 'rgb(245,245,245)';
+export var TRUE_WHITE = 'rgb(255, 255, 255)';
+export var PALE_WHITE = 'rgba(245,245,245, 0.5)';
+export var GREEN = 'rgb(0, 213, 146)';
+export var RED = 'rgb(237, 82, 82)';
+export var SAND_YELLOW = 'rgb(244, 218,97)';
+export var SAND_YELLOW_25 = 'rgba(244, 218,97, 0.25)';
+export var SAND_YELLOW_50 = 'rgba(244, 218, 97, 0.5)';
+export var BLUE_LED = 'rgba(0, 0, 128, 0.5)';
+export var GREEN_LED = 'rgba(0, 128, 0, 0.5)';
+export var PINK_LED = 'rgba(128, 0, 128, 0.5)';
+export var DASHBUTTON_BLUE = 'rgb(198,234,239)';
+export var DASHBORDER_BLUE = 'rgb(175,221,233)';
+export var INDICATOR_GREEN = 'rgb(11, 158, 46)';
+export var INDICATOR_ORANGE = 'rgb(253, 180, 1)';
+export var INDICATOR_RED = 'rgb(237, 82, 82)';
+export var INDICATOR_WHITE = 'rgba(245,245,245, 0.5)';
+//Changed the lightness value in HSL colour picker to get new lighter RGB values
+export var SCREENFREE_PURPLE = 'rgb(118, 53, 151)';
+export var SCREENFREE_GREEN = 'rgb(3, 125, 60)';
+export var SCREENFREE_YELLOW = 'rgb(250, 217, 5)';
+export var SCREENFREE_RED = 'rgb(91, 20, 19)';
+export var SCREENFREE_BLUE = 'rgb(0, 170, 255)';
+//Original RB values for the screenfree cards
+// export const SCREENFREE_PURPLE = 'rgb(47, 21, 60)';
+// export const SCREENFREE_GREEN  = 'rgb( 1, 55, 26)';
+// export const SCREENFREE_YELLOW = 'rgb(97, 85,  2)';
+// export const SCREENFREE_RED    = 'rgb(91, 20, 19)';
+// export const SCREENFREE_BLUE   = 'rgb( 0, 57, 85)';

package/dist-types/src/types/communication-between-apps/wrapper-communication.d.ts

@@ -0,0 +1,45 @@
+export interface IAppSentMessage {
+    message: AppSentMessage;
+    data?: any;
+    messagePromiseId: string;
+}
+export interface IWrapperSentMessage {
+    message: WrapperSentMessage;
+    data?: any;
+    messagePromiseId: string;
+}
+export declare enum AppSentMessage {
+    RAFT_IS_CONNECTED = "RAFT_IS_CONNECTED",
+    RAFT_CONNECT = "RAFT_CONNECT",
+    RAFT_GET_NAME = "RAFT_GET_NAME",
+    RAFT_VERIFY = "RAFT_VERIFY",
+    RAFT_VERIFY_PHONE = "RAFT_VERIFY_PHONE",
+    RAFT_STOP_VERIFY = "RAFT_STOP_VERIFY",
+    RAFT_DISCONNECT = "RAFT_DISCONNECT",
+    RAFT_START_DISCOVERY = "RAFT_START_DISCOVERY",
+    RAFT_SELECT = "RAFT_SELECT",
+    RAFT_SEND_REST = "RAFT_SEND_REST",
+    GET_MISSED_CONN_EVENT = "GET_MISSED_CONN_EVENT",
+    RAFT_STREAM_AUDIO = "RAFT_STREAM_AUDIO",
+    SAVE_FILE_ON_DEVICE = "SAVE_FILE_ON_DEVICE",
+    SAVE_FILE_ON_DEVICE_LOCAL_STORAGE = "SAVE_FILE_ON_DEVICE_LOCAL_STORAGE",
+    LOAD_FILE_FROM_DEVICE_LOCAL_STORAGE = "LOAD_FILE_FROM_DEVICE_LOCAL_STORAGE",
+    DELETE_FILE_FROM_DEVICE_LOCAL_STORAGE = "DELETE_FILE_FROM_DEVICE_LOCAL_STORAGE",
+    LIST_FILES_FROM_DEVICE_LOCAL_STORAGE = "LIST_FILES_FROM_DEVICE_LOCAL_STORAGE"
+}
+export declare enum WrapperSentMessage {
+    RAFT_PUBLISHED_EVENT = "RAFT_PUBLISHED_EVENT",
+    RAFT_CONNECTED_RESULTS = "RAFT_CONNECTED_RESULTS"
+}
+export interface WRAPPER_RESPONSE_BASE {
+    success: boolean;
+    error?: string;
+    results?: any;
+    messagePromiseId: string;
+}
+export interface WEB_APP_MESSAGE_BASE {
+    success: boolean;
+    error?: string;
+    results?: any;
+    messagePromiseId: string;
+}

package/dist-types/src/types/communication-between-apps/wrapper-communication.js

@@ -0,0 +1,25 @@
+export var AppSentMessage;
+(function (AppSentMessage) {
+    AppSentMessage["RAFT_IS_CONNECTED"] = "RAFT_IS_CONNECTED";
+    AppSentMessage["RAFT_CONNECT"] = "RAFT_CONNECT";
+    AppSentMessage["RAFT_GET_NAME"] = "RAFT_GET_NAME";
+    AppSentMessage["RAFT_VERIFY"] = "RAFT_VERIFY";
+    AppSentMessage["RAFT_VERIFY_PHONE"] = "RAFT_VERIFY_PHONE";
+    AppSentMessage["RAFT_STOP_VERIFY"] = "RAFT_STOP_VERIFY";
+    AppSentMessage["RAFT_DISCONNECT"] = "RAFT_DISCONNECT";
+    AppSentMessage["RAFT_START_DISCOVERY"] = "RAFT_START_DISCOVERY";
+    AppSentMessage["RAFT_SELECT"] = "RAFT_SELECT";
+    AppSentMessage["RAFT_SEND_REST"] = "RAFT_SEND_REST";
+    AppSentMessage["GET_MISSED_CONN_EVENT"] = "GET_MISSED_CONN_EVENT";
+    AppSentMessage["RAFT_STREAM_AUDIO"] = "RAFT_STREAM_AUDIO";
+    AppSentMessage["SAVE_FILE_ON_DEVICE"] = "SAVE_FILE_ON_DEVICE";
+    AppSentMessage["SAVE_FILE_ON_DEVICE_LOCAL_STORAGE"] = "SAVE_FILE_ON_DEVICE_LOCAL_STORAGE";
+    AppSentMessage["LOAD_FILE_FROM_DEVICE_LOCAL_STORAGE"] = "LOAD_FILE_FROM_DEVICE_LOCAL_STORAGE";
+    AppSentMessage["DELETE_FILE_FROM_DEVICE_LOCAL_STORAGE"] = "DELETE_FILE_FROM_DEVICE_LOCAL_STORAGE";
+    AppSentMessage["LIST_FILES_FROM_DEVICE_LOCAL_STORAGE"] = "LIST_FILES_FROM_DEVICE_LOCAL_STORAGE";
+})(AppSentMessage || (AppSentMessage = {}));
+export var WrapperSentMessage;
+(function (WrapperSentMessage) {
+    WrapperSentMessage["RAFT_PUBLISHED_EVENT"] = "RAFT_PUBLISHED_EVENT";
+    WrapperSentMessage["RAFT_CONNECTED_RESULTS"] = "RAFT_CONNECTED_RESULTS";
+})(WrapperSentMessage || (WrapperSentMessage = {}));

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

@@ -0,0 +1,10 @@
+export declare enum RaftInfoEvents {
+    RAFT_NAME = "RAFT_NAME",
+    SYSTEM_INFO = "SYSTEM_INFO",
+    STATE_INFO = "STATE_INFO",
+    RAFT_VERSION = "RAFT_VERSION",
+    RAFT_SERIAL_NO = "RAFT_SERIAL_NO",
+    RAFT_MSG = "RAFT_MSG",
+    IS_REGISTERED_TO_WARRANTY = "IS_REGISTERED_TO_WARRANTY",
+    RAFT_IS_VERIFIED = "RAFT_IS_VERIFIED"
+}

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

@@ -0,0 +1,11 @@
+export var RaftInfoEvents;
+(function (RaftInfoEvents) {
+    RaftInfoEvents["RAFT_NAME"] = "RAFT_NAME";
+    RaftInfoEvents["SYSTEM_INFO"] = "SYSTEM_INFO";
+    RaftInfoEvents["STATE_INFO"] = "STATE_INFO";
+    RaftInfoEvents["RAFT_VERSION"] = "RAFT_VERSION";
+    RaftInfoEvents["RAFT_SERIAL_NO"] = "RAFT_SERIAL_NO";
+    RaftInfoEvents["RAFT_MSG"] = "RAFT_MSG";
+    RaftInfoEvents["IS_REGISTERED_TO_WARRANTY"] = "IS_REGISTERED_TO_WARRANTY";
+    RaftInfoEvents["RAFT_IS_VERIFIED"] = "RAFT_IS_VERIFIED";
+})(RaftInfoEvents || (RaftInfoEvents = {}));

package/dist-types/src/types/phone-app-communicator.d.ts

@@ -0,0 +1,20 @@
+export declare enum EventsE {
+    FOUND_RAFT_ON_DISCOVERY = "found-raft-on-discovery",
+    DISCOVERY_ENDED = "discovery-ended"
+}
+export type PHONE_APP_RESPONSE_BASE = {
+    success: boolean;
+    error?: string;
+    eventName?: EventsE;
+};
+export type START_DISCOVERY_RESPONSE = PHONE_APP_RESPONSE_BASE & {
+    didStartDiscovery: boolean;
+};
+export type FOUND_RAFT_ON_DISCOVERY_RESPONSE = PHONE_APP_RESPONSE_BASE & {
+    foundRIC: {
+        _id: string;
+        _localName: string;
+        _name: string;
+        _rssi: number;
+    };
+};

package/dist-types/src/types/phone-app-communicator.js

@@ -0,0 +1,5 @@
+export var EventsE;
+(function (EventsE) {
+    EventsE["FOUND_RAFT_ON_DISCOVERY"] = "found-raft-on-discovery";
+    EventsE["DISCOVERY_ENDED"] = "discovery-ended";
+})(EventsE || (EventsE = {}));

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 "@robdobsn/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): 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("@robdobsn/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;